<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html dir="ltr" xmlns="http://www.w3.org/1999/xhtml" typeof="bibo:Document">
<head>
<title>JSON-LD API 1.0</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />

<!-- 
  === NOTA BENE ===
  For the three scripts below, if your spec resides on dev.w3 you can check them
  out in the same tree and use relative links so that they'll work offline,
   -->



<style type="text/css">
.diff { font-weight:bold; color:#0a3; }
</style>
<style type="text/css">/*****************************************************************
 * ReSpec 3 CSS
 * Robin Berjon - http://berjon.com/
 *****************************************************************/

/* --- INLINES --- */
em.rfc2119 { 
    text-transform:     lowercase;
    font-variant:       small-caps;
    font-style:         normal;
    color:              #900;
}

h1 acronym, h2 acronym, h3 acronym, h4 acronym, h5 acronym, h6 acronym, a acronym,
h1 abbr, h2 abbr, h3 abbr, h4 abbr, h5 abbr, h6 abbr, a abbr {
    border: none;
}

dfn {
    font-weight:    bold;
}

a.internalDFN {
    color:  inherit;
    border-bottom:  1px solid #99c;
    text-decoration:    none;
}

a.externalDFN {
    color:  inherit;
    border-bottom:  1px dotted #ccc;
    text-decoration:    none;
}

a.bibref {
    text-decoration:    none;
}

cite .bibref {
    font-style: normal;
}

code {
    color:  #ff4500;
}


/* --- --- */
ol.algorithm { counter-reset:numsection; list-style-type: none; }
ol.algorithm li { margin: 0.5em 0; }
ol.algorithm li:before { font-weight: bold; counter-increment: numsection; content: counters(numsection, ".") ") "; }


/* --- WEB IDL --- */
pre.idl {
    border-top: 1px solid #90b8de;
    border-bottom: 1px solid #90b8de;
    padding:    1em;
    line-height:    120%;
}

pre.idl::before {
    content:    "WebIDL";
    display:    block;
    width:      150px;
    background: #90b8de;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

.idlType {
    color:  #ff4500;
    font-weight:    bold;
    text-decoration:    none;
}

/*.idlModule*/
/*.idlModuleID*/
/*.idlInterface*/
.idlInterfaceID, .idlDictionaryID, .idlCallbackID, .idlEnumID {
    font-weight:    bold;
    color:  #005a9c;
}

.idlSuperclass {
    font-style: italic;
    color:  #005a9c;
}

/*.idlAttribute*/
.idlAttrType, .idlFieldType, .idlMemberType {
    color:  #005a9c;
}
.idlAttrName, .idlFieldName, .idlMemberName {
    color:  #ff4500;
}
.idlAttrName a, .idlFieldName a, .idlMemberName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlMethod*/
.idlMethType, .idlCallbackType {
    color:  #005a9c;
}
.idlMethName {
    color:  #ff4500;
}
.idlMethName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlParam*/
.idlParamType {
    color:  #005a9c;
}
.idlParamName {
    font-style: italic;
}

.extAttr {
    color:  #666;
}

/*.idlConst*/
.idlConstType {
    color:  #005a9c;
}
.idlConstName {
    color:  #ff4500;
}
.idlConstName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlException*/
.idlExceptionID {
    font-weight:    bold;
    color:  #c00;
}

.idlTypedefID, .idlTypedefType {
    color:  #005a9c;
}

.idlRaises, .idlRaises a.idlType, .idlRaises a.idlType code, .excName a, .excName a code {
    color:  #c00;
    font-weight:    normal;
}

.excName a {
    font-family:    monospace;
}

.idlRaises a.idlType, .excName a.idlType {
    border-bottom:  1px dotted #c00;
}

.excGetSetTrue, .excGetSetFalse, .prmNullTrue, .prmNullFalse, .prmOptTrue, .prmOptFalse {
    width:  45px;
    text-align: center;
}
.excGetSetTrue, .prmNullTrue, .prmOptTrue { color:  #0c0; }
.excGetSetFalse, .prmNullFalse, .prmOptFalse { color:  #c00; }

.idlImplements a {
    font-weight:    bold;
}

dl.attributes, dl.methods, dl.constants, dl.fields, dl.dictionary-members {
    margin-left:    2em;
}

.attributes dt, .methods dt, .constants dt, .fields dt, .dictionary-members dt {
    font-weight:    normal;
}

.attributes dt code, .methods dt code, .constants dt code, .fields dt code, .dictionary-members dt code {
    font-weight:    bold;
    color:  #000;
    font-family:    monospace;
}

.attributes dt code, .fields dt code, .dictionary-members dt code {
    background:  #ffffd2;
}

.attributes dt .idlAttrType code, .fields dt .idlFieldType code, .dictionary-members dt .idlMemberType code {
    color:  #005a9c;
    background:  transparent;
    font-family:    inherit;
    font-weight:    normal;
    font-style: italic;
}

.methods dt code {
    background:  #d9e6f8;
}

.constants dt code {
    background:  #ddffd2;
}

.attributes dd, .methods dd, .constants dd, .fields dd, .dictionary-members dd {
    margin-bottom:  1em;
}

table.parameters, table.exceptions {
    border-spacing: 0;
    border-collapse:    collapse;
    margin: 0.5em 0;
    width:  100%;
}
table.parameters { border-bottom:  1px solid #90b8de; }
table.exceptions { border-bottom:  1px solid #deb890; }

.parameters th, .exceptions th {
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
    font-family:    initial;
    font-weight:    normal;
    text-shadow:    #666 1px 1px 0;
}
.parameters th { background: #90b8de; }
.exceptions th { background: #deb890; }

.parameters td, .exceptions td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
    vertical-align: top;
}

.parameters tr:first-child td, .exceptions tr:first-child td {
    border-top: none;
}

.parameters td.prmName, .exceptions td.excName, .exceptions td.excCodeName {
    width:  100px;
}

.parameters td.prmType {
    width:  120px;
}

table.exceptions table {
    border-spacing: 0;
    border-collapse:    collapse;
    width:  100%;
}

/* --- TOC --- */
.toc a, .tof a {
    text-decoration:    none;
}

a .secno, a .figno {
    color:  #000;
}

ul.tof, ol.tof {
    list-style: none outside none;
}

.caption {
    margin-top: 0.5em;
    font-style:   italic;
}

/* --- TABLE --- */
table.simple {
    border-spacing: 0;
    border-collapse:    collapse;
    border-bottom:  3px solid #005a9c;
}

.simple th {
    background: #005a9c;
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
}

.simple th[scope="row"] {
    background: inherit;
    color:  inherit;
    border-top: 1px solid #ddd;
}

.simple td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
}

.simple tr:nth-child(even) {
    background: #f0f6ff;
}

/* --- DL --- */
.section dd > p:first-child {
    margin-top: 0;
}

.section dd > p:last-child {
    margin-bottom: 0;
}

.section dd {
    margin-bottom:  1em;
}

.section dl.attrs dd, .section dl.eldef dd {
    margin-bottom:  0;
}
</style><style type="text/css">/* --- EXAMPLES --- */
div.example-title {
    min-width: 7.5em;
    color: #b9ab2d;
}
div.example-title span {
    text-transform: uppercase;   
}
div.example, div.illegal-example {
    padding: 0.5em;
    margin: 1em 0;
    position: relative;
    clear: both;
}
div.illegal-example { color: red }
div.illegal-example p { color: black }
div.example {
    padding: .5em;
    border-left-width: .5em;
    border-left-style: solid;
    border-color: #e0cb52;
    background: #fcfaee;    
}
</style><style type="text/css">/* --- ISSUES/NOTES --- */
div.issue-title, div.note-title {
    padding-right:  1em;
    min-width: 7.5em;
    color: #b9ab2d;
}
div.issue-title { color: #e05252; }
div.note-title { color: #52e052; }
div.issue-title span, div.note-title span {
    text-transform: uppercase;
}
div.note, div.issue {
    margin-top: 1em;
    margin-bottom: 1em;
}
.note > p:first-child, .issue > p:first-child { margin-top: 0 }
.issue, .note {
    padding: .5em;
    border-left-width: .5em;
    border-left-style: solid;
}
div.issue, div.note {
    padding: 0.5em;
    margin: 1em 0;
    position: relative;
    clear: both;
}
span.note, span.issue { padding: .1em .5em .15em; }

.issue {
    border-color: #e05252;
    background: #fbe9e9;
}
.note {
    border-color: #52e052;
    background: #e9fbe9;
}


</style><link rel="stylesheet" href="http://www.w3.org/community/src/css/spec/cg-final.css" /><script type="text/javascript" src="http://s3.amazonaws.com/green-turtle/RDFa.0.15.0.js"></script><meta name="green-turtle-rdfa-message" content="{ &quot;type&quot;: &quot;status&quot;, &quot;loaded&quot;: true, &quot;count&quot;: 45 }" /><style type='text/css'>
.diff-old-a {
  font-size: smaller;
  color: red;
}

.diff-new { background-color: yellow; }
.diff-chg { background-color: lime; }
.diff-new:before,
.diff-new:after
    { content: "\2191" }
.diff-chg:before, .diff-chg:after
    { content: "\2195" }
.diff-old { text-decoration: line-through; background-color: #FBB; }
.diff-old:before,
.diff-old:after
    { content: "\2193" }
:focus { border: thin red solid}
</style>
</head>


<body>
<div class="head">
<p>
<a href="http://www.w3.org/">
<img width="72" height="48" src="http://www.w3.org/Icons/w3c_home" alt="W3C" />
<del class="diff-old">The
</del>
</a>
</p>
<h1 class="title" id="title">
JSON-LD
API
1.0
</h1>
<h2 id="subtitle">
An
Application
Programming
Interface
for
the
JSON-LD
Syntax
</h2>
<del class="diff-old">Unofficial
Draft
24
May
</del>
<h2 id="final-community-group-specification-26-june-2012">
<ins class="diff-chg">Final
Community
Group
Specification
26
June
</ins>
2012
</h2>
<dl>
<dt>
<ins class="diff-new">Latest
editor's
draft:
</ins></dt><dd><a href="http://json-ld.org/spec/latest/json-ld-api/"><ins class="diff-new">
http://json-ld.org/spec/latest/json-ld-api/
</ins></a>
</dd>
<dt>
Editors:
</dt>
<dd rel="bibo:editor" inlist="">
<span typeof="foaf:Person">
<a rel="foaf:homepage" property="foaf:name" content="Manu Sporny" href="http://manu.sporny.org/">
Manu
Sporny
</a>,
<a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</span>
</dd>
<dd rel="bibo:editor" inlist="">
<span typeof="foaf:Person">
<a rel="foaf:homepage" property="foaf:name" content="Gregg Kellogg" href="http://greggkellogg.net/">
Gregg
Kellogg
</a>,
<a rel="foaf:workplaceHomepage" href="http://kellogg-assoc.com/">
Kellogg
Associates
</a>
</span>
</dd>
<dd rel="bibo:editor" inlist="">
<span typeof="foaf:Person">
<a rel="foaf:homepage" property="foaf:name" content="Dave Longley" href="http://digitalbazaar.com/">
Dave
Longley
</a>,
<a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</span>
</dd>
<dd rel="bibo:editor" inlist="">
<span typeof="foaf:Person">
<a rel="foaf:homepage" property="foaf:name" content="Markus Lanthaler" href="http://www.markus-lanthaler.com/">
Markus
Lanthaler
</a>,
<a rel="foaf:workplaceHomepage" href="http://www.tugraz.at/">
Graz
University
of
Technology
</a>
</span>
</dd>
<dt>
Authors:
</dt>
<dd rel="dcterms:contributor">
<span typeof="foaf:Person">
<a rel="foaf:homepage" property="foaf:name" content="Dave Longley" href="http://digitalbazaar.com/">
Dave
Longley
</a>,
<a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</span>
</dd>
<dd rel="dcterms:contributor">
<span typeof="foaf:Person">
<a rel="foaf:homepage" property="foaf:name" content="Manu Sporny" href="http://digitalbazaar.com/">
Manu
Sporny
</a>,
<a rel="foaf:workplaceHomepage" href="http://digitalbazaar.com/">
Digital
Bazaar
</a>
</span>
</dd>
<dd rel="dcterms:contributor">
<span typeof="foaf:Person">
<a rel="foaf:homepage" property="foaf:name" content="Gregg Kellogg" href="http://greggkellogg.net/">
Gregg
Kellogg
</a>,
<a rel="foaf:workplaceHomepage" href="http://kellogg-assoc.com/">
Kellogg
Associates
</a>
</span>
</dd>
<dd rel="dcterms:contributor">
<span typeof="foaf:Person">
<a rel="foaf:homepage" property="foaf:name" content="Markus Lanthaler" href="http://www.markus-lanthaler.com/">
Markus
Lanthaler
</a>,
<a rel="foaf:workplaceHomepage" href="http://www.tugraz.at/">
Graz
University
of
Technology
</a>
</span>
</dd>
</dl>
<p>
This
document
is
also
available
in
this
non-normative
format:
<a href="diff-20120524.html">
diff
to
previous
version
<del class="diff-old">.
</del>
</a>
</p>
<p class="copyright">
<del class="diff-old">This
document
is
licensed
</del>
<a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">
<ins class="diff-chg">Copyright
</ins></a><ins class="diff-chg">
©
2010-2012
the
Contributors
to
the
JSON-LD
API
1.0
Specification,
published
by
the
</ins><a href="http://www.w3.org/community/json-ld/"><ins class="diff-chg">
JSON
for
Linking
Data
Community
Group
</ins></a>
under
<del class="diff-old">a
Creative
Commons
Attribution
3.0
License
</del>
<ins class="diff-chg">the
</ins><a href="https://www.w3.org/community/about/agreements/fsa/"><ins class="diff-chg">
W3C
Community
Final
Specification
Agreement
(FSA)
</ins>
</a>.
<ins class="diff-new">A
human-readable
</ins><a href="http://www.w3.org/community/about/agreements/fsa-deed/"><ins class="diff-new">
summary
</ins></a><ins class="diff-new">
is
available.
</ins>
</p>
<hr />
</div>
<div id="abstract" class="introductory section">
<h2>
Abstract
</h2>
<p>
JSON
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
]
has
proven
to
be
a
highly
useful
object
serialization
and
messaging
format.
JSON-LD
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-JSON-LD">
JSON-LD
</a>
</cite>
]
harmonizes
the
representation
of
Linked
Data
in
JSON
by
outlining
a
common
JSON
representation
format
for
expressing
directed
graphs;
mixing
both
Linked
Data
and
non-Linked
Data
in
a
single
document.
This
document
outlines
an
Application
Programming
Interface
and
a
set
of
algorithms
for
programmatically
transforming
JSON-LD
<del class="diff-old">documents.
</del>
<ins class="diff-chg">documents
in
order
to
make
them
easier
to
work
with
in
programming
environments
like
JavaScript,
Python,
and
Ruby.
</ins>
</p>
</div>
<div id="sotd" class="introductory section">
<h2>
Status
of
This
Document
</h2>
<p>
This
<del class="diff-old">document
</del>
<ins class="diff-chg">specification
was
published
by
the
</ins><a href="http://www.w3.org/community/json-ld/"><ins class="diff-chg">
JSON
for
Linking
Data
Community
Group
</ins></a>.<ins class="diff-chg">
It
</ins>
is
<del class="diff-old">merely
</del>
<ins class="diff-chg">not
</ins>
a
<del class="diff-old">public
working
draft
</del>
<ins class="diff-chg">W3C
Standard
nor
is
it
on
the
W3C
Standards
Track.
Please
note
that
under
the
</ins><a href="https://www.w3.org/community/about/agreements/final/"><ins class="diff-chg">
W3C
Community
Final
Specification
Agreement
(FSA)
</ins></a><ins class="diff-chg">
other
conditions
apply.
Learn
more
about
</ins><a href="http://www.w3.org/community/"><ins class="diff-chg">
W3C
Community
and
Business
Groups
</ins></a>.</p><p><ins class="diff-chg">
This
document
has
been
under
development
for
over
18
months
in
the
JSON
for
Linking
Data
Community
Group.
The
document
has
recently
been
approved
for
transfer
into
the
RDF
Working
Group
for
review
with
the
intent
to
publish
the
document
along
the
W3C
Recommendation
track.
This
specification
has
undergone
significant
development,
review,
and
changes
during
the
course
</ins>
of
<ins class="diff-new">the
last
18
months
and
is
being
published
as
</ins>
a
<del class="diff-old">potential
</del>
<ins class="diff-chg">Final
Community
Group
Specification
so
that
it
may
gain
wider
review
and
feedback.
</ins></p><p><ins class="diff-chg">
There
are
currently
</ins><a href="http://json-ld.org/#impl"><ins class="diff-chg">
five
interoperable
implementations
</ins></a><ins class="diff-chg">
of
this
</ins>
specification.
<ins class="diff-new">There
is
a
</ins><a href="https://github.com/json-ld/json-ld.org/tree/main/test-suite"><ins class="diff-new">
fairly
complete
test
suite
</ins></a><ins class="diff-new">
and
a
</ins><a href="http://json-ld.org/playground/"><ins class="diff-new">
live
JSON-LD
editor
</ins></a><ins class="diff-new">
that
is
capable
of
demonstrating
the
features
described
in
this
document.
While
development
on
implementations,
the
test
suite
and
the
live
editor
will
continue,
they
are
believed
to
be
mature
enough
to
be
integrated
into
a
non-production
system
at
this
point
in
time
with
the
expectation
that
they
could
be
used
in
a
production
system
within
the
next
year.
</ins></p><div class="issue"><div class="issue-title"><span><ins class="diff-new">
Issue
1
</ins></span></div><p class="">
It
<del class="diff-old">has
no
official
standing
</del>
<ins class="diff-chg">is
important
for
readers
to
understand
that
the
scope
</ins>
of
<del class="diff-old">any
kind
</del>
<ins class="diff-chg">this
document
is
currently
under
debate
</ins>
and
<del class="diff-old">does
not
represent
</del>
<ins class="diff-chg">new
features
may
be
added
to
</ins>
the
<del class="diff-old">support
</del>
<ins class="diff-chg">specification.
Existing
features
may
be
modified
heavily
</ins>
or
<del class="diff-old">consensus
of
any
standards
organisation.
</del>
<ins class="diff-chg">removed
entirely
from
the
specification
upon
further
review
and
feedback
from
the
broader
community.
</ins>
This
<del class="diff-old">document
</del>
is
<del class="diff-old">an
experimental
</del>
<ins class="diff-chg">a
</ins>
work
in
<del class="diff-old">progress.
</del>
<ins class="diff-chg">progress
and
publication
as
a
First
Public
Working
Draft
does
not
require
that
all
Working
Group
members
agree
on
the
content
of
the
document.
</ins>
</p>
</div>
</div>
<div id="toc" class="section">
<h2 class="introductory">
Table
of
Contents
</h2>
<ul class="toc">
<li class="tocline">
<a href="#preface" class="tocxref">
<span class="secno">
1.
</span>
<del class="diff-old">Introduction
</del>
<ins class="diff-chg">Preface
</ins>
</a>
<ul class="toc">
<li class="tocline">
<a href="#contributing" class="tocxref">
<span class="secno">
1.1
</span>
<del class="diff-old">How
to
Read
this
Document
</del>
<ins class="diff-chg">Contributing
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#introduction" class="tocxref">
<span class="secno">
<del class="diff-old">1.2
</del>
<ins class="diff-chg">2.
</ins>
</span>
<del class="diff-old">Linked
Data
</del>
<ins class="diff-chg">Introduction
</ins></a><ul class="toc"><li class="tocline"><a href="#expansion" class="tocxref"><span class="secno"><ins class="diff-chg">
2.1
</ins></span><ins class="diff-chg">
Expansion
</ins>
</a>
</li>
<li class="tocline">
<a href="#compaction" class="tocxref">
<span class="secno">
<del class="diff-old">1.3
</del>
<ins class="diff-chg">2.2
</ins>
</span>
<del class="diff-old">Contributing
</del>
<ins class="diff-chg">Compaction
</ins></a></li><li class="tocline"><a href="#conversion-to-and-from-rdf" class="tocxref"><span class="secno"><ins class="diff-chg">
2.3
</ins></span><ins class="diff-chg">
Conversion
to
and
from
RDF
</ins></a></li><li class="tocline"><a href="#framing-and-normalization" class="tocxref"><span class="secno"><ins class="diff-chg">
2.4
</ins></span><ins class="diff-chg">
Framing
and
Normalization
</ins>
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#the-application-programming-interface" class="tocxref">
<span class="secno">
<del class="diff-old">2.
</del>
<ins class="diff-chg">3.
</ins>
</span>
The
Application
Programming
Interface
</a>
<ul class="toc">
<li class="tocline">
<a href="#general-terminology" class="tocxref">
<span class="secno">
<ins class="diff-new">3.1
</ins></span><ins class="diff-new">
General
Terminology
</ins></a></li><li class="tocline">
<a href="#jsonldprocessor" class="tocxref">
<span class="secno">
<del class="diff-old">2.1
</del>
<ins class="diff-chg">3.2
</ins>
</span>
JsonLdProcessor
</a>
<ul class="toc">
<li class="tocline">
<a href="#methods" class="tocxref">
<span class="secno">
<del class="diff-old">2.1.1
</del>
<ins class="diff-chg">3.2.1
</ins>
</span>
Methods
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#callbacks" class="tocxref">
<span class="secno">
<del class="diff-old">2.2
</del>
<ins class="diff-chg">3.3
</ins>
</span>
Callbacks
</a>
<ul class="toc">
<li class="tocline">
<a href="#jsonldcallback" class="tocxref">
<span class="secno">
<del class="diff-old">2.2.1
</del>
<ins class="diff-chg">3.3.1
</ins>
</span>
JsonLdCallback
</a>
<ul class="toc">
<li class="tocline">
<a href="#methods-1" class="tocxref">
<span class="secno">
<del class="diff-old">2.2.1.1
</del>
<ins class="diff-chg">3.3.1.1
</ins>
</span>
Methods
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#quadcallback" class="tocxref">
<span class="secno">
<del class="diff-old">2.2.2
</del>
<ins class="diff-chg">3.3.2
</ins>
</span>
QuadCallback
</a>
<ul class="toc">
<li class="tocline">
<a href="#methods-2" class="tocxref">
<span class="secno">
<del class="diff-old">2.2.2.1
</del>
<ins class="diff-chg">3.3.2.1
</ins>
</span>
Methods
</a>
</li>
</ul>
</li>
</ul>
</li>
<li class="tocline">
<a href="#data-structures" class="tocxref">
<span class="secno">
<del class="diff-old">2.3
</del>
<ins class="diff-chg">3.4
</ins>
</span>
Data
Structures
</a>
<ul class="toc">
<li class="tocline">
<a href="#url" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.1
</del>
<ins class="diff-chg">3.4.1
</ins>
</span>
URL
</a>
</li>
<li class="tocline">
<a href="#jsonldoptions" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.2
</del>
<ins class="diff-chg">3.4.2
</ins>
</span>
JsonLdOptions
</a>
</li>
<li class="tocline">
<a href="#quad" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.3
</del>
<ins class="diff-chg">3.4.3
</ins>
</span>
Quad
</a>
<ul class="toc">
<li class="tocline">
<a href="#attributes" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.3.1
</del>
<ins class="diff-chg">3.4.3.1
</ins>
</span>
Attributes
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#node" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.4
</del>
<ins class="diff-chg">3.4.4
</ins>
</span>
Node
</a>
<del class="diff-old">2.3.4.1
Attributes
</del>
</li>
<li class="tocline">
<a href="#iri" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.5
</del>
<ins class="diff-chg">3.4.5
</ins>
</span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
<ul class="toc">
<li class="tocline">
<a href="#attributes-1" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.5.1
</del>
<ins class="diff-chg">3.4.5.1
</ins>
</span>
Attributes
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#blank-node" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.6
</del>
<ins class="diff-chg">3.4.6
</ins>
</span>
<span title="blank_node">
Blank
Node
</span>
</a>
<ul class="toc">
<li class="tocline">
<a href="#attributes-2" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.6.1
</del>
<ins class="diff-chg">3.4.6.1
</ins>
</span>
Attributes
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#literal" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.7
</del>
<ins class="diff-chg">3.4.7
</ins>
</span>
Literal
</a>
<ul class="toc">
<li class="tocline">
<a href="#attributes-3" class="tocxref">
<span class="secno">
<del class="diff-old">2.3.7.1
</del>
<ins class="diff-chg">3.4.7.1
</ins>
</span>
Attributes
</a>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</li>
<li class="tocline">
<a href="#algorithms" class="tocxref">
<span class="secno">
<del class="diff-old">3.
</del>
<ins class="diff-chg">4.
</ins>
</span>
Algorithms
</a>
<ul class="toc">
<li class="tocline">
<del class="diff-old">3.1
Syntax
Tokens
and
Keywords
</del>
<a href="#algorithm-terms" class="tocxref">
<span class="secno">
<del class="diff-old">3.2
</del>
<ins class="diff-chg">4.1
</ins>
</span>
Algorithm
Terms
</a>
</li>
<li class="tocline">
<a href="#context-processing" class="tocxref">
<span class="secno">
<del class="diff-old">3.3
</del>
<ins class="diff-chg">4.2
</ins>
</span>
Context
Processing
</a>
</li>
<li class="tocline">
<a href="#iri-expansion" class="tocxref">
<span class="secno">
<del class="diff-old">3.4
</del>
<ins class="diff-chg">4.3
</ins>
</span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
</li>
<li class="tocline">
<a href="#iri-compaction" class="tocxref">
<span class="secno">
<del class="diff-old">3.5
</del>
<ins class="diff-chg">4.4
</ins>
</span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
<ul class="toc">
<li class="tocline">
<a href="#iri-compaction-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.5.1
</del>
<ins class="diff-chg">4.4.1
</ins>
</span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
Algorithm
</a>
</li>
<li class="tocline">
<a href="#term-rank-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.5.2
</del>
<ins class="diff-chg">4.4.2
</ins>
</span>
Term
Rank
Algorithm
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#value-expansion" class="tocxref">
<span class="secno">
<del class="diff-old">3.6
</del>
<ins class="diff-chg">4.5
</ins>
</span>
Value
Expansion
</a>
</li>
<li class="tocline">
<a href="#value-compaction" class="tocxref">
<span class="secno">
<del class="diff-old">3.7
</del>
<ins class="diff-chg">4.6
</ins>
</span>
Value
Compaction
</a>
</li>
<li class="tocline">
<del class="diff-old">3.8
Generate
Blank
Node
Identifier
</del>
<a href="#expansion-1" class="tocxref">
<span class="secno">
<del class="diff-old">3.9
</del>
<ins class="diff-chg">4.7
</ins>
</span>
Expansion
</a>
<ul class="toc">
<li class="tocline">
<a href="#expansion-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.9.1
</del>
<ins class="diff-chg">4.7.1
</ins>
</span>
Expansion
Algorithm
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#compaction-1" class="tocxref">
<span class="secno">
<del class="diff-old">3.10
</del>
<ins class="diff-chg">4.8
</ins>
</span>
Compaction
</a>
<ul class="toc">
<li class="tocline">
<a href="#compaction-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.10.1
</del>
<ins class="diff-chg">4.8.1
</ins>
</span>
Compaction
Algorithm
</a>
</li>
</ul>
</li>
<li class="tocline">
<del class="diff-old">3.11
Framing
3.11.1
Framing
Algorithm
Terms
3.11.2
Framing
Algorithm
3.11.3
Subject
Map
Generation
3.11.4
Remove
Embedded
Definition
3.11.5
Embed
Values
3.12
Flattening
3.12.1
Flattening
Algorithm
</del>
<a href="#rdf-conversion" class="tocxref">
<span class="secno">
<del class="diff-old">3.13
</del>
<ins class="diff-chg">4.9
</ins>
</span>
RDF
Conversion
</a>
<ul class="toc">
<li class="tocline">
<a href="#overview" class="tocxref">
<span class="secno">
<del class="diff-old">3.13.1
</del>
<ins class="diff-chg">4.9.1
</ins>
</span>
Overview
</a>
</li>
<li class="tocline">
<a href="#parsing-examples" class="tocxref">
<span class="secno">
<del class="diff-old">3.13.2
</del>
<ins class="diff-chg">4.9.2
</ins>
</span>
<del class="diff-old">RDF
Conversion
Algorithm
Terms
</del>
<ins class="diff-chg">Parsing
Examples
</ins>
</a>
</li>
<li class="tocline">
<a href="#convert-to-rdf-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.13.3
</del>
<ins class="diff-chg">4.9.3
</ins>
</span>
Convert
to
RDF
Algorithm
</a>
</li>
<li class="tocline">
<a href="#list-conversion" class="tocxref">
<span class="secno">
<del class="diff-old">3.13.4
</del>
<ins class="diff-chg">4.9.4
</ins>
</span>
List
Conversion
</a>
</li>
<li class="tocline">
<a href="#convert-from-rdf-algorithm" class="tocxref">
<span class="secno">
<del class="diff-old">3.13.5
</del>
<ins class="diff-chg">4.9.5
</ins>
</span>
Convert
from
RDF
Algorithm
</a>
</li>
</ul>
</li>
</ul>
</li>
<li class="tocline">
<a href="#data-round-tripping" class="tocxref">
<span class="secno">
<del class="diff-old">4.
</del>
<ins class="diff-chg">5.
</ins>
</span>
Data
Round
Tripping
</a>
</li>
<li class="tocline">
<a href="#appendix-a" class="tocxref">
<span class="secno">
A.
</span>
<del class="diff-old">IANA
Considerations
B.
</del>
Initial
Context
</a>
</li>
<li class="tocline">
<a href="#acknowledgements" class="tocxref">
<span class="secno">
<del class="diff-old">C.
</del>
<ins class="diff-chg">B.
</ins>
</span>
Acknowledgements
</a>
</li>
<li class="tocline">
<a href="#references" class="tocxref">
<span class="secno">
<del class="diff-old">D.
</del>
<ins class="diff-chg">C.
</ins>
</span>
References
</a>
<ul class="toc">
<li class="tocline">
<a href="#normative-references" class="tocxref">
<span class="secno">
<del class="diff-old">D.1
</del>
<ins class="diff-chg">C.1
</ins>
</span>
Normative
references
</a>
</li>
<li class="tocline">
<a href="#informative-references" class="tocxref">
<span class="secno">
<del class="diff-old">D.2
</del>
<ins class="diff-chg">C.2
</ins>
</span>
Informative
references
</a>
</li>
</ul>
</li>
</ul>
</div>
<div id="preface" class="section">
<h2>
<span class="secno">
1.
</span>
<del class="diff-old">Introduction
</del>
<ins class="diff-chg">Preface
</ins>
</h2>
<p>
<del class="diff-old">JSON,
as
specified
in
[
RFC4627
],
is
a
simple
language
for
representing
data
on
the
Web.
Linked
Data
is
a
technique
for
creating
a
graph
of
interlinked
data
across
different
documents
or
Web
sites.
Data
entities
are
described
using
IRI
s,
which
are
typically
dereferencable
and
thus
may
be
used
to
find
more
information
about
an
entity,
creating
a
&quot;Web
of
Knowledge&quot;.
JSON-LD
is
intended
to
be
a
simple
publishing
method
for
expressing
not
only
Linked
Data
in
JSON,
but
also
for
adding
semantics
to
existing
JSON.
JSON-LD
is
designed
as
a
light-weight
syntax
that
can
be
used
to
express
Linked
Data.
It
is
primarily
intended
to
be
a
way
to
use
Linked
Data
in
Javascript
and
other
Web-based
programming
environments.
It
is
also
useful
when
building
interoperable
Web
services
and
when
storing
Linked
Data
in
JSON-based
document
storage
engines.
It
is
practical
and
designed
to
be
as
simple
as
possible,
utilizing
the
large
number
of
JSON
parsers
and
libraries
available
today.
It
is
designed
to
be
able
to
express
key-value
pairs,
RDF
data,
RDFa
[
RDFA-CORE
]
data,
Microformats
[
MICROFORMATS
]
data,
and
Microdata
[
MICRODATA
].
That
is,
it
supports
every
major
Web-based
structured
data
model
in
use
today.
The
syntax
does
not
necessarily
require
applications
to
change
their
JSON,
but
allows
to
easily
add
meaning
by
adding
context
in
a
way
that
is
either
in-band
or
out-of-band.
The
syntax
is
designed
to
not
disturb
already
deployed
systems
running
on
JSON,
but
provide
a
smooth
upgrade
path
from
JSON
to
JSON
with
added
semantics.
Finally,
the
format
is
intended
to
be
easy
to
parse,
efficient
to
generate,
convertible
to
RDF
in
one
pass,
and
require
a
very
small
memory
footprint
in
order
to
operate.
1.1
How
to
Read
this
Document
</del>
This
document
is
a
detailed
specification
for
<del class="diff-old">a
serialization
of
Linked
Data
in
JSON.
</del>
<ins class="diff-chg">an
Application
Programming
Interface
for
the
JSON-LD
Syntax.
</ins>
The
document
is
primarily
intended
for
the
following
audiences:
</p>
<ul>
<li>
<del class="diff-old">Authors
</del>
<ins class="diff-chg">Web
authors
and
developers
</ins>
that
want
a
very
detailed
view
of
how
<ins class="diff-new">a
</ins>
JSON-LD
<del class="diff-old">processors
operate.
</del>
<ins class="diff-chg">processor
and
the
API
operates.
</ins>
</li>
<li>
Software
developers
that
want
to
implement
processors
and
APIs
for
JSON-LD.
</li>
</ul>
<p>
To
understand
the
basics
in
this
specification
you
must
first
be
familiar
with
JSON,
which
is
detailed
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
].
You
must
also
understand
the
JSON-LD
Syntax
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-JSON-LD">
JSON-LD
</a>
</cite>
],
which
is
the
base
syntax
used
by
all
of
the
algorithms
in
this
document.
To
understand
the
API
and
how
it
is
intended
to
operate
in
a
programming
environment,
it
is
useful
to
have
working
knowledge
of
the
JavaScript
programming
language
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-ECMA-262">
ECMA-262
</a>
</cite>
]
and
WebIDL
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-WEBIDL">
WEBIDL
</a>
</cite>
].
To
understand
how
JSON-LD
maps
to
RDF,
it
is
helpful
to
be
familiar
with
the
basic
RDF
concepts
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">
RDF-CONCEPTS
</a>
</cite>
].
</p>
<div id="contributing" class="section">
<h3>
<span class="secno">
<ins class="diff-new">1.1
</ins></span><ins class="diff-new">
Contributing
</ins></h3>
<p>
<del class="diff-old">Examples
</del>
<ins class="diff-chg">There
are
a
number
of
ways
that
one
</ins>
may
<del class="diff-old">contain
references
</del>
<ins class="diff-chg">participate
in
the
development
of
this
specification:
</ins></p><ul><li><ins class="diff-chg">
If
you
want
</ins>
to
<del class="diff-old">existing
vocabularies
</del>
<ins class="diff-chg">make
sure
that
your
feedback
is
formally
addressed
by
the
RDF
Working
Group,
you
should
send
it
to
public-rdf-comments:
</ins><a href="http://lists.w3.org/Archives/Public/public-rdf-comments/"><ins class="diff-chg">
public-rdf-comments@w3.org
</ins></a></li><li><ins class="diff-chg">
Ad-hoc
technical
discussion
primarily
occurs
on
the
public
community
mailing
list:
</ins><a href="http://lists.w3.org/Archives/Public/public-linked-json/"><ins class="diff-chg">
public-linked-json@w3.org
</ins></a></li><li><a href="http://json-ld.org/minutes/"><ins class="diff-chg">
Public
JSON-LD
Community
Group
teleconferences
</ins></a><ins class="diff-chg">
are
held
on
Tuesdays
at
1500UTC
every
week.
</ins></li><li><ins class="diff-chg">
RDF
Working
Group
teleconferences
are
held
on
Wednesdays
at
1500UTC
every
week.
Participation
is
limited
to
RDF
Working
Group
members.
</ins></li><li><ins class="diff-chg">
Specification
bugs
</ins>
and
<del class="diff-old">use
prefix
</del>
<ins class="diff-chg">issues
should
be
reported
in
the
</ins><a href="https://github.com/json-ld/json-ld.org/issues"><ins class="diff-chg">
issue
tracker
</ins>
</a>
<del class="diff-old">es
</del>
<ins class="diff-chg">if
you
do
not
want
</ins>
to
<del class="diff-old">refer
</del>
<ins class="diff-chg">send
an
e-mail
</ins>
to
<del class="diff-old">vocabularies.
</del>
<ins class="diff-chg">the
public-rdf-comments
mailing
list.
</ins></li><li><a href="https://github.com/json-ld/json-ld.org/tree/main/spec"><ins class="diff-chg">
Source
code
</ins></a><ins class="diff-chg">
for
the
specification
can
be
found
on
Github.
</ins></li><li>
The
<del class="diff-old">following
</del>
<a href="http://webchat.freenode.net/?channels=json-ld">
<ins class="diff-chg">#json-ld
</ins></a><ins class="diff-chg">
IRC
channel
</ins>
is
<ins class="diff-new">available
for
real-time
discussion
on
irc.freenode.net.
</ins></li></ul></div></div><div id="introduction" class="section"><h2><span class="secno"><ins class="diff-new">
2.
</ins></span><ins class="diff-new">
Introduction
</ins></h2><p><ins class="diff-new">
The
JSON-LD
Syntax
specification
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-JSON-LD"><ins class="diff-new">
JSON-LD
</ins></a></cite><ins class="diff-new">
]
outlines
</ins>
a
<del class="diff-old">list
</del>
<ins class="diff-chg">language
that
may
be
used
to
express
Linked
Data
in
JSON.
Often,
it
is
useful
to
be
able
to
transform
JSON-LD
documents
so
that
they
may
be
easily
processed
in
a
programming
environment
like
JavaScript,
Python
or
Ruby.
</ins></p><p><ins class="diff-chg">
There
are
three
major
types
</ins>
of
<del class="diff-old">all
vocabularies
</del>
<ins class="diff-chg">transformation
that
are
discussed
in
this
document;
compaction,
expansion,
</ins>
and
<ins class="diff-new">RDF
conversion.
</ins></p><div id="expansion" class="section"><h3><span class="secno"><ins class="diff-new">
2.1
</ins></span><ins class="diff-new">
Expansion
</ins></h3><p><ins class="diff-new">
Software
algorithms
are
easiest
to
write
when
the
data
that
they
are
processing
have
a
regular
form.
Since
information
can
be
represented
by
JSON-LD
in
a
variety
of
different
ways,
transforming
all
of
these
methods
into
a
uniform
structure
allows
the
developer
to
simplify
</ins>
their
<del class="diff-old">prefix
</del>
<ins class="diff-chg">processing
code.
For
example,
note
that
the
following
input
uses
only
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins>
</a>
<del class="diff-old">abbreviations,
</del>
<ins class="diff-chg">s
and
is
fairly
compact:
</ins></p>  <div class="example"><div class="example-title"><span>Example 1</span></div><pre class="example">var input1 = {<ins class="diff-chg">
  &quot;@context&quot;: &quot;http://json-ld.org/contexts/person.jsonld&quot;
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}
</ins></pre></div><p><ins class="diff-chg">
The
next
input
example
uses
one
</ins><a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr></a><ins class="diff-chg">
to
express
a
property,
but
leaves
the
rest
of
the
information
untouched.
</ins></p>  <div class="example"><div class="example-title"><span>Example 2</span></div><pre class="example">var input2 = {<ins class="diff-chg">
  &quot;@context&quot;: &quot;http://json-ld.org/contexts/person.jsonld&quot;
  &quot;<span class="diff">http://xmlns.com/foaf/0.1/name</span>&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}
</ins></pre></div><p><ins class="diff-chg">
While
both
inputs
are
valid
JSON-LD,
writing
a
program
to
handle
every
permutation
of
possible
inputs
can
be
difficult,
especially
when
the
incoming
context
could
change
</ins>
as
<del class="diff-old">used
</del>
<ins class="diff-chg">well.
To
ensure
that
the
data
can
be
given
a
more
uniform
structure,
JSON-LD
introduces
the
notion
of
expansion.
</ins><dfn title="expansion" id="dfn-expansion"><ins class="diff-chg">
Expansion
</ins></dfn><ins class="diff-chg">
performs
two
important
operations.
The
first
is
to
expand
all
values
that
are
</ins><a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr></a><ins class="diff-chg">
s
to
their
fully
expanded
form.
The
second
is
to
express
all
values
</ins>
in
<del class="diff-old">this
document:
</del>
<dfn title="expanded_form" id="dfn-expanded_form">
<ins class="diff-chg">expanded
form
</ins></dfn>.<ins class="diff-chg">
To
transform
both
inputs
above
to
the
same
representation,
the
developer
could
do
the
following:
</ins>
</p>
  <div class="example"><div class="example-title"><span>Example 3</span></div><pre class="example">function expansionCallback(output) {
<ins class="diff-chg">   console.log(output);
}
// the second parameter is 'null' because the developer does not wish to
// inject another context value
jsonld.expand(input1, null, expansionCallback);
jsonld.expand(input2,
null,
expansionCallback);
</ins></pre></div><p>
The
<del class="diff-old">Dublin
Core
</del>
<ins class="diff-chg">output
for
both
calls
above
will
be:
</ins></p>  <div class="example"><div class="example-title"><span>Example 4</span></div><pre class="example">[{<ins class="diff-chg">
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{
    &quot;@value&quot;: &quot;Manu Sporny&quot;
  }],
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: [{
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }]
}]
</ins></pre></div><p><ins class="diff-chg">
Note
that
in
the
example
above;
all
</ins><a class="tref internalDFN" title="context" href="#dfn-context"><ins class="diff-chg">
context
</ins>
</a>
<del class="diff-old">vocabulary
(abbreviation:
dc
,
e.g.,
dc:title
)
The
Friend
</del>
<ins class="diff-chg">definitions
have
been
removed,
all
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
and
prefixes
have
been
expanded
to
full
IRIs,
and
all
</ins><a class="tref internalDFN" title="literal" href="#dfn-literal"><ins class="diff-chg">
literal
</ins></a><ins class="diff-chg">
s
are
expressed
in
</ins><a class="tref internalDFN" title="expanded_form" href="#dfn-expanded_form"><ins class="diff-chg">
expanded
form
</ins></a>.<ins class="diff-chg">
While
the
output
is
more
difficult
for
a
human
to
read,
it
is
easier
for
a
software
program
to
process
because
</ins>
of
<ins class="diff-new">its
very
regular
structure.
</ins></p></div><div id="compaction" class="section"><h3><span class="secno"><ins class="diff-new">
2.2
</ins></span><ins class="diff-new">
Compaction
</ins></h3><p><ins class="diff-new">
While
expansion
expands
</ins>
a
<del class="diff-old">Friend
</del>
<ins class="diff-chg">given
input
as
much
as
possible,
compaction
performs
the
opposite
operation
-
expressing
a
given
input
as
succinctly
as
possible.
While
expansion
is
meant
to
produce
something
that
is
easy
to
process
by
software
programs,
compaction
is
meant
to
produce
something
that
is
easy
to
ready
by
software
developers.
Compaction
uses
a
developer-supplied
</ins><a class="tref internalDFN" title="context" href="#dfn-context"><ins class="diff-chg">
context
</ins>
</a>
<del class="diff-old">vocabulary
(abbreviation:
foaf
,
e.g.,
foaf:knows
)
The
RDF
</del>
<ins class="diff-chg">to
compresses
all
</ins><a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier"><ins class="diff-chg">
IRI
</ins></abbr>
</a>
<del class="diff-old">vocabulary
(abbreviation:
rdf
,
e.g.,
rdf:type
)
</del>
<ins class="diff-chg">s
to
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins></a><ins class="diff-chg">
s
or
</ins><a class="tref internalDFN" title="prefix" href="#dfn-prefix"><ins class="diff-chg">
prefix
</ins></a><ins class="diff-chg">
es,
and
compacts
all
</ins><a class="tref internalDFN" title="literal" href="#dfn-literal"><ins class="diff-chg">
literal
</ins></a><ins class="diff-chg">
s
expressed
in
</ins><a class="tref internalDFN" title="expanded_form" href="#dfn-expanded_form"><ins class="diff-chg">
expanded
form
</ins></a><ins class="diff-chg">
as
much
as
possible.
</ins></p><p>
The
<del class="diff-old">XSD
</del>
<ins class="diff-chg">following
example
expresses
input
that
has
already
been
fully
expanded:
</ins></p>  <div class="example"><div class="example-title"><span>Example 5</span></div><pre class="example">var expandedInput = [{<ins class="diff-chg">
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{
    &quot;@value&quot;: &quot;Manu Sporny&quot;
  }],
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: [{
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }]
}]
</ins></pre></div><p><ins class="diff-chg">
A
developer
that
wants
to
transform
the
data
above
into
a
more
human-readable
form,
could
do
the
following
using
the
JSON-LD
API:
</ins></p>  <div class="example"><div class="example-title"><span>Example 6</span></div><pre class="example">function compactionCallback(output) {<ins class="diff-chg">
   console.log(output);
}
jsonld.compact(expandedInput,
&quot;http://json-ld.org/contexts/person.jsonld&quot;,
compactionCallback);
</ins></pre></div><p><ins class="diff-chg">
The
following
would
be
the
result
of
the
call
above:
</ins></p>  <div class="example"><div class="example-title"><span>Example 7</span></div><pre class="example">{<ins class="diff-chg">
  &quot;@context&quot;: &quot;http://json-ld.org/contexts/person.jsonld&quot;
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}
</ins></pre></div><p><ins class="diff-chg">
Note
that
all
of
the
</ins><a class="tref internalDFN" title="term" href="#dfn-term"><ins class="diff-chg">
term
</ins>
</a>
<del class="diff-old">vocabulary
(abbreviation:
xsd
,
e.g.,
xsd:integer
)
</del>
<ins class="diff-chg">s
have
been
compressed
and
the
</ins><a class="tref internalDFN" title="context" href="#dfn-context"><ins class="diff-chg">
context
</ins></a><ins class="diff-chg">
has
been
injected
into
the
output.
While
compacted
output
is
most
useful
to
humans,
it
can
also
be
carefully
used
to
generate
structures
that
are
easy
to
use
for
developers
to
program
against
as
well.
</ins></p></div><div id="conversion-to-and-from-rdf" class="section"><h3><span class="secno"><ins class="diff-chg">
2.3
</ins></span><ins class="diff-chg">
Conversion
to
and
from
RDF
</ins></h3>
<p>
<del class="diff-old">JSON
</del>
<ins class="diff-chg">JSON-LD
can
be
used
to
losslessly
express
the
RDF
data
model
as
described
in
the
RDF
Concepts
document
</ins>
[
<cite>
<del class="diff-old">RFC4627
</del>
<a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">
<ins class="diff-chg">RDF-CONCEPTS
</ins>
</a>
</cite>
<del class="diff-old">]
defines
several
terms
which
</del>
<ins class="diff-chg">].
This
ensures
that
data
can
be
round-tripped
from
any
RDF
syntax,
like
N-Triples
or
TURTLE,
without
any
loss
in
the
fidelity
of
the
data.
Assume
the
following
RDF
input
in
N-Triples
format:
</ins></p>  <div class="example"><div class="example-title"><span>Example 8</span></div><pre class="example">var data = &quot;<ins class="diff-chg">
&lt;http://manu.sporny.org/about/#manu&gt; &lt;http://xmlns.com/foaf/0.1/name&gt; \&quot;Manu Sporny\&quot; .\n
&lt;http://manu.sporny.org/about/#manu&gt;
&lt;http://xmlns.com/foaf/0.1/homepage&gt;
&lt;http://manu.sporny.org/&gt;
.&quot;;
</ins></pre></div><p><ins class="diff-chg">
A
developer
can
use
the
JSON-LD
API
to
transform
the
markup
above
into
a
JSON-LD
document:
</ins></p>  <div class="example"><div class="example-title"><span>Example 9</span></div><pre class="example">function conversionCallback(result)<ins class="diff-chg">
{
  console.log(&quot;JSON-LD Document: &quot;, result);
};
jsonld.fromRDF(data,
conversionCallback,
{&quot;format&quot;:
&quot;ntriples&quot;});
</ins></pre></div><p><ins class="diff-chg">
The
following
expanded
output
would
be
the
result
of
the
call
above:
</ins></p>  <div class="example"><div class="example-title"><span>Example 10</span></div><pre class="example">[{<ins class="diff-chg">
  &quot;@id&quot;: &quot;http://manu.sporny.org/about/#manu&quot;,
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{
    &quot;@value&quot;: &quot;Manu Sporny&quot;
  }],
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: [{
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }]
}]
</ins></pre></div><p><ins class="diff-chg">
Note
that
the
output
above,
could
easily
be
compacted
to
produce
the
following
using
the
technique
outlined
in
the
previous
section:
</ins></p>  <div class="example"><div class="example-title"><span>Example 11</span></div><pre class="example">{<ins class="diff-chg">
  &quot;@context&quot;: &quot;http://json-ld.org/contexts/person.jsonld&quot;,
  &quot;@id&quot;: &quot;http://manu.sporny.org/about/#manu&quot;,
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}
</ins></pre></div><p><ins class="diff-chg">
Transforming
the
object
above
back
to
RDF
is
as
simple
as
calling
the
</ins><code><ins class="diff-chg">
toRDF()
</ins></code><ins class="diff-chg">
method:
</ins></p>  <div class="example"><div class="example-title"><span>Example 12</span></div><pre class="example">var jsonldDocument = ...; // assign the JSON-LD document here<ins class="diff-chg">
function rdfCallback(quads)
{
  console.log(&quot;RDF Data: &quot;, quads);
};
jsonld.toRDF(jsonldDocument,
rdfCallback);
</ins></pre></div></div><div id="framing-and-normalization" class="section"><h3><span class="secno"><ins class="diff-chg">
2.4
</ins></span><ins class="diff-chg">
Framing
and
Normalization
</ins></h3><div class="issue"><div class="issue-title"><span><ins class="diff-chg">
Issue
2
</ins></span></div><p class=""><ins class="diff-chg">
There
are
currently
two
other
API
methods
that
are
in
active
development
and
were
not
ready
for
publication
at
the
time
this
document
was
published.
Framing
allows
a
developer
to
force
a
different
layout
for
the
data
and
effectively
perform
query-by-example
on
JSON-LD
documents
-
this
is
most
useful
when
a
JSON-LD-based
REST
API
does
not
know
the
exact
form
of
the
data
it
is
getting
in,
but
still
wants
to
operate
upon
it
if
some
bare
essentials
</ins>
are
<ins class="diff-new">found
in
the
data.
JSON-LD
normalization
allows
JSON-LD
documents
to
be
deterministically
serialized
such
that
they
can
be
digitally
signed
or
be
</ins>
used
<del class="diff-old">throughout
</del>
<ins class="diff-chg">to
find
the
differences
between
two
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a><ins class="diff-chg">
s.
It
is
expected
that
framing
will
be
a
part
of
the
final
API.
It
is
expected
that
normalization
will
be
an
optional
feature
that
JSON-LD
processors
may
implement.
</ins></p></div></div></div><div id="the-application-programming-interface" class="section"><h2><span class="secno"><ins class="diff-chg">
3.
</ins></span><ins class="diff-chg">
The
Application
Programming
Interface
</ins></h2><p><ins class="diff-chg">
This
API
provides
a
clean
mechanism
that
enables
developers
to
convert
JSON-LD
data
into
a
a
variety
of
output
formats
that
are
easier
to
work
with
in
various
programming
languages.
If
a
JSON-LD
API
is
provided
in
a
programming
environment,
the
entirety
of
the
following
API
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
be
implemented.
</ins></p><div id="general-terminology" class="section"><h3><span class="secno"><ins class="diff-chg">
3.1
</ins></span><ins class="diff-chg">
General
Terminology
</ins></h3><div class="issue"><div class="issue-title"><span><ins class="diff-chg">
Issue
3
</ins></span></div><p class=""><ins class="diff-chg">
The
intent
of
the
Working
Group
and
the
Editors
of
</ins>
this
<del class="diff-old">document:
</del>
<ins class="diff-chg">specification
is
to
eventually
align
terminology
used
in
this
document
with
the
terminology
used
in
the
RDF
Concepts
document
to
the
extent
to
which
it
makes
sense
to
do
so.
In
general,
if
there
is
an
analogue
to
terminology
used
in
this
document
in
the
RDF
Concepts
document,
the
preference
is
to
use
the
terminology
in
the
RDF
Concepts
document.
</ins>
</p>
</div>
<p>
<ins class="diff-new">The
following
is
an
explanation
of
the
general
terminology
used
in
this
document:
</ins></p>
<dl>
<dt>
<dfn title="json_object" id="dfn-json_object">
JSON
object
</dfn>
</dt>
<dd>
An
object
structure
is
represented
as
a
pair
of
curly
brackets
surrounding
zero
or
more
<del class="diff-old">name/value
</del>
<ins class="diff-chg">name-value
</ins>
pairs.
A
name
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>.
A
single
colon
comes
after
each
name,
separating
the
name
from
the
value.
A
single
comma
separates
a
value
from
a
following
name.
The
names
within
an
object
<em class="rfc2119" title="should">
should
</em>
be
unique.
</dd>
<dt>
<dfn title="array" id="dfn-array">
array
</dfn>
</dt>
<dd>
An
array
is
<del class="diff-old">an
ordered
collection
of
values.
An
array
structure
is
</del>
represented
as
square
brackets
surrounding
zero
or
more
values
<del class="diff-old">(or
elements).
Elements
</del>
<ins class="diff-chg">that
</ins>
are
separated
by
commas.
<del class="diff-old">Within
JSON-LD,
array
order
is
not
preserved
by
default,
unless
specific
markup
is
provided.
This
is
because
the
basic
data
model
of
JSON-LD
is
a
linked
data
graph
,
which
is
inherently
unordered.
</del>
</dd>
<dt>
<dfn title="string" id="dfn-string">
string
</dfn>
</dt>
<dd>
A
string
is
a
sequence
of
zero
or
more
Unicode
<ins class="diff-new">(UTF-8)
</ins>
characters,
wrapped
in
double
quotes,
using
backslash
<del class="diff-old">escapes.
</del>
<ins class="diff-chg">escapes
(if
necessary).
</ins>
A
character
is
represented
as
a
single
character
string.
</dd>
<dt>
<dfn title="number" id="dfn-number">
number
</dfn>
</dt>
<dd>
A
number
is
<del class="diff-old">is
</del>
similar
to
that
used
in
most
programming
languages,
except
that
the
octal
and
hexadecimal
formats
are
not
used
and
that
leading
zeros
are
not
allowed.
</dd>
<dt>
<dfn title="true" id="dfn-true">
true
</dfn>
and
<dfn title="false" id="dfn-false">
false
</dfn>
</dt>
<dd>
<del class="diff-old">Boolean
values.
</del>
<ins class="diff-chg">Values
that
are
used
to
express
one
of
two
possible
boolean
states.
</ins>
</dd>
<dt>
<dfn title="null" id="dfn-null">
null
</dfn>
</dt>
<dd>
<del class="diff-old">The
use
</del>
<ins class="diff-chg">Unless
otherwise
specified,
a
JSON-LD
processor
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
act
as
if
a
key-value
pair
in
the
body
</ins>
of
<ins class="diff-new">a
JSON-LD
document
was
never
declared
when
</ins>
the
<del class="diff-old">null
</del>
value
<del class="diff-old">within
JSON-LD
</del>
<ins class="diff-chg">equals
</ins><em><ins class="diff-chg">
null
</ins></em>.<ins class="diff-chg">
If
</ins><code><ins class="diff-chg">
@value
</ins></code>,<code><ins class="diff-chg">
@list
</ins></code>,<ins class="diff-chg">
or
</ins><code><ins class="diff-chg">
@set
</ins></code>
is
<del class="diff-old">used
</del>
<ins class="diff-chg">set
</ins>
to
<del class="diff-old">ignore
or
</del>
<em>
<ins class="diff-chg">null
</ins></em><ins class="diff-chg">
in
expanded
form,
then
the
entire
JSON
object
is
ignored.
If
</ins><code><ins class="diff-chg">
@context
</ins></code><ins class="diff-chg">
is
set
to
</ins><em><ins class="diff-chg">
null
</ins></em>,<ins class="diff-chg">
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
is
</ins>
reset
<del class="diff-old">values.
</del>
<ins class="diff-chg">and
when
used
within
a
</ins><a class="tref internalDFN" title="context" href="#dfn-context"><ins class="diff-chg">
context
</ins></a>,<ins class="diff-chg">
it
removes
any
definition
associated
with
the
key,
unless
otherwise
specified.
</ins>
</dd>
<dt>
<dfn title="subject_definition" id="dfn-subject_definition">
subject
definition
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
used
to
represent
a
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
and
one
or
more
properties
of
that
subject.
A
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
is
a
subject
definition
if
it
does
not
contain
<del class="diff-old">the
</del>
<ins class="diff-chg">they
</ins>
keys
<code>
@value
</code>,
<code>
@list
</code>
or
<code>
@set
</code>
and
it
has
one
or
more
keys
other
than
<code>
@id
</code>.
</dd>
<dt>
<dfn title="subject_reference" id="dfn-subject_reference">
subject
reference
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
used
to
reference
a
subject
having
only
the
<code>
@id
</code>
key.
</dd>
<del class="diff-old">1.2
Linked
Data
The
following
definition
for
Linked
Data
is
the
one
that
will
be
used
for
this
specification.
</del>
<dt>
<dfn title="linked_data" id="dfn-linked_data">
Linked
Data
</dfn>
<del class="diff-old">is
a
</del>
</dt>
<dd>
<ins class="diff-chg">A
</ins>
set
of
documents,
each
containing
a
representation
of
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
<del class="diff-old">graph.
A
</del>
<ins class="diff-chg">graph
</ins></a>.</dd><dt>
<dfn title="linked_data_graph" id="dfn-linked_data_graph">
linked
data
graph
</dfn>
<del class="diff-old">is
an
</del>
<ins class="diff-chg">or
</ins><dfn title="dataset" id="dfn-dataset"><ins class="diff-chg">
dataset
</ins></dfn></dt><dd><ins class="diff-chg">
An
</ins>
unordered
labeled
directed
graph,
where
<del class="diff-old">nodes
</del>
<a class="tref internalDFN" title="node" href="#dfn-node">
<ins class="diff-chg">node
</ins></a><ins class="diff-chg">
s
</ins>
are
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
s
or
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
s,
and
edges
are
properties.
</dd>
<dt>
<dfn title="node" id="dfn-node">
<ins class="diff-chg">node
</ins></dfn></dt><dd>
A
<ins class="diff-new">piece
of
information
that
is
represented
in
a
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-new">
linked
data
graph
</ins></a>.</dd><dt><dfn title="named_graph" id="dfn-named_graph"><ins class="diff-new">
named
graph
</ins></dfn></dt><dd><ins class="diff-new">
A
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-new">
linked
data
graph
</ins></a><ins class="diff-new">
that
has
one
or
more
</ins><a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier"><ins class="diff-new">
IRI
</ins></abbr></a><ins class="diff-new">
that
are
used
to
refer
to
it.
</ins></dd><dt><dfn title="graph_name" id="dfn-graph_name"><ins class="diff-new">
graph
name
</ins></dfn></dt><dd><ins class="diff-new">
An
</ins><a class="tref internalDFN" title="iri" href="#dfn-iri"><abbr title="Internationalized Resource Identifier"><ins class="diff-new">
IRI
</ins></abbr></a><ins class="diff-new">
that
is
a
reference
to
a
</ins><a class="tref internalDFN" title="named_graph" href="#dfn-named_graph"><ins class="diff-new">
named
graph
</ins></a>.</dd><dt><dfn title="default_graph" id="dfn-default_graph"><ins class="diff-new">
default
graph
</ins></dfn></dt><dd><ins class="diff-new">
When
executing
an
algorithm,
the
graph
where
data
should
be
placed
if
a
</ins><a class="tref internalDFN" title="named_graph" href="#dfn-named_graph"><ins class="diff-new">
named
graph
</ins></a><ins class="diff-new">
is
not
specified.
</ins></dd><dt>
<dfn title="subject" id="dfn-subject">
subject
</dfn>
<del class="diff-old">is
any
</del>
</dt>
<dd>
<ins class="diff-chg">Any
</ins>
node
in
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>
with
at
least
one
outgoing
edge.
<del class="diff-old">A
subject
should
be
labeled
with
an
</del>
</dd>
<dt>
<dfn title="iri" id="dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</dfn>
<del class="diff-old">(an
</del>
</dt>
<dd>
<ins class="diff-chg">An
</ins>
Internationalized
Resource
Identifier
as
described
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC3987">
RFC3987
</a>
</cite>
]).
<del class="diff-old">An
</del>
</dd>
<dt>
<dfn title="object" id="dfn-object">
object
</dfn>
<del class="diff-old">is
a
</del>
</dt>
<dd>
<ins class="diff-chg">A
</ins>
node
in
a
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>
with
at
least
one
incoming
edge.
<del class="diff-old">An
object
may
be
labeled
with
an
IRI
</del>
</dd>
<dt>
<del class="diff-old">.
An
object
may
be
a
subject
and
object
at
the
same
time.
A
</del>
<dfn title="property" id="dfn-property">
property
</dfn>
<del class="diff-old">is
an
</del>
</dt>
<dd>
<ins class="diff-chg">An
</ins>
edge
of
the
<a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">
linked
data
graph
</a>.
<del class="diff-old">A
property
</del>
</dd>
<dt>
<dfn title="literal" id="dfn-literal">
<ins class="diff-chg">literal
</ins></dfn></dt><dd><ins class="diff-chg">
An
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins>
</a>
<del class="diff-old">should
be
labeled
</del>
with
<ins class="diff-new">a
label
that
is
not
</ins>
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
<del class="diff-old">An
</del>
</dd>
<dt>
<del class="diff-old">IRI
</del>
<dfn title="quad" id="dfn-quad">
<ins class="diff-chg">quad
</ins></dfn>
</dt>
<dd>
<ins class="diff-chg">A
piece
of
information
</ins>
that
<del class="diff-old">is
a
label
in
a
linked
data
graph
should
be
dereferencable
to
</del>
<ins class="diff-chg">contains
four
items;
</ins>
a
<del class="diff-old">Linked
Data
document
describing
the
labeled
</del>
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>,
<del class="diff-old">object
or
</del>
<ins class="diff-chg">a
</ins>
<a class="tref internalDFN" title="property" href="#dfn-property">
property
<del class="diff-old">.
A
literal
is
an
</del>
</a>,
<ins class="diff-chg">a
</ins>
<a class="tref internalDFN" title="object" href="#dfn-object">
object
<del class="diff-old">with
</del>
</a>,
<ins class="diff-chg">and
</ins>
a
<del class="diff-old">label
that
is
not
an
</del>
<a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">
<ins class="diff-chg">graph
name
</ins></a>.</dd><dt>
<del class="diff-old">IRI
</del>
<dfn title="context" id="dfn-context">
<ins class="diff-chg">context
</ins></dfn>
</dt>
<dd>
<ins class="diff-new">A
</ins><a class="tref internalDFN" title="json_object" href="#dfn-json_object"><ins class="diff-new">
JSON
object
</ins>
</a>
<del class="diff-old">Note
</del>
that
<del class="diff-old">the
definition
for
Linked
Data
above
is
silent
on
the
topic
of
unlabeled
nodes.
Unlabeled
nodes
are
not
considered
Linked
Data
.
However,
this
specification
allows
</del>
<ins class="diff-chg">contains
rules
</ins>
for
<del class="diff-old">the
expression
of
unlabled
nodes,
as
most
graph-based
data
sets
on
the
Web
contain
</del>
<ins class="diff-chg">interpreting
</ins>
a
<del class="diff-old">number
of
associated
nodes
that
are
not
named
and
thus
are
not
directly
de-referenceable.
</del>
<ins class="diff-chg">JSON-LD
document.
</ins></dd><dt>
<del class="diff-old">1.3
Contributing
There
are
a
number
of
ways
</del>
<dfn title="keyword" id="dfn-keyword">
<ins class="diff-chg">keyword
</ins></dfn></dt><dd><ins class="diff-chg">
A
JSON
key
</ins>
that
<del class="diff-old">one
may
participate
</del>
<ins class="diff-chg">is
specific
to
JSON-LD,
specified
</ins>
in
the
<del class="diff-old">development
of
this
specification:
Technical
discussion
typically
occurs
on
the
public
mailing
list:
public-linked-json@w3.org
</del>
<ins class="diff-chg">JSON-LD
Syntax
specification
[
</ins><cite>
<del class="diff-old">Public
teleconferences
</del>
<a class="bibref" rel="biblioentry" href="#bib-JSON-LD">
<ins class="diff-chg">JSON-LD
</ins>
</a>
<del class="diff-old">are
held
on
Tuesdays
at
1500UTC
on
the
second
and
fourth
week
of
each
month.
Specification
bugs
and
issues
should
be
reported
</del>
</cite>
<ins class="diff-chg">]
</ins>
in
the
<del class="diff-old">issue
tracker
</del>
<ins class="diff-chg">section
titled
</ins><a href="http://sites.local/json-ld.org/spec/latest/json-ld-syntax/#syntax-tokens-and-keywords"><ins class="diff-chg">
Syntax
Tokens
and
Keywords
</ins>
</a>.
<del class="diff-old">Source
code
for
the
specification
can
be
found
on
Github.
The
#json-ld
IRC
channel
is
available
for
real-time
discussion
on
irc.freenode.net.
</del>
</dd>
</dl>
</div>
<div id="jsonldprocessor" class="section">
<h3>
<span class="secno">
<del class="diff-old">2.
</del>
<ins class="diff-chg">3.2
</ins>
</span>
<del class="diff-old">The
Application
Programming
Interface
</del>
<ins class="diff-chg">JsonLdProcessor
</ins></h3>
<p>
<del class="diff-old">This
API
provides
a
clean
mechanism
that
enables
developers
to
convert
JSON-LD
data
into
a
a
variety
of
output
formats
that
are
easier
to
work
with
in
various
programming
languages.
If
a
</del>
<ins class="diff-chg">The
</ins>
JSON-LD
<del class="diff-old">API
</del>
<ins class="diff-chg">Processor
interface
</ins>
is
<del class="diff-old">provided
in
a
programming
environment,
</del>
the
<del class="diff-old">entirety
of
</del>
<ins class="diff-chg">high-level
programming
structure
that
developers
use
to
access
</ins>
the
<del class="diff-old">following
API
must
be
implemented.
</del>
<ins class="diff-chg">JSON-LD
transformation
methods.
</ins>
</p>
<del class="diff-old">2.1
JsonLdProcessor
</del>
    <pre class="idl"><span class="idlInterface" id="idl-def-JsonLdProcessor">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">JsonLdProcessor</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-expand-void-object-or-object---or-URL-input-object-or-URL-context-JsonLdCallback-callback-JsonLdOptions-options">expand</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or URL</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>object or URL</a>?</span> <span class="idlParamName">context</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-compact-void-object-or-object---or-URL-input-object-or-URL-context-JsonLdCallback-callback-JsonLdOptions-options">compact</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or URL</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a>object or URL</a></span> <span class="idlParamName">context</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-fromRDF-void-QuadArray-input-JsonLdCallback-callback-JsonLdOptions-options">fromRDF</a></span> (<span class="idlParam"><span class="idlParamType"><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a>[]</span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-JsonLdCallback" class="idlType"><code>JsonLdCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdProcessor-toRDF-void-object-or-object---or-URL-input-QuadCallback-callback-JsonLdOptions-options">toRDF</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object[] or URL</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam"><span class="idlParamType"><a href="#idl-def-QuadCallback" class="idlType"><code>QuadCallback</code></a></span> <span class="idlParamName">callback</span></span>, <span class="idlParam">optional <span class="idlParamType"><a href="#idl-def-JsonLdOptions" class="idlType"><code>JsonLdOptions</code></a></span> <span class="idlParamName">options</span></span>);</span>
};</span>
</pre>
<div id="methods" class="section">
<h2>
<span class="secno">
<del class="diff-old">2.1.1
</del>
<ins class="diff-chg">3.2.1
</ins>
</span>
Methods
</h2>
<dl class="methods">
<dt id="widl-JsonLdProcessor-compact-void-object-or-object---or-URL-input-object-or-URL-context-JsonLdCallback-callback-JsonLdOptions-options">
<code>
compact
</code>
</dt>
<dd>
<a href="#compaction">
Compacts
</a>
the
given
<code>
input
</code>
using
the
<code>
context
</code>
according
to
the
steps
in
the
<a href="#compaction-algorithm">
Compaction
Algorithm
</a>.
The
<code>
input
</code>
<em class="rfc2119" title="must">
must
</em>
be
copied,
compacted
and
returned
if
there
are
no
errors.
If
the
compaction
fails,
an
<del class="diff-old">appropirate
</del>
<ins class="diff-chg">appropriate
</ins>
exception
<em class="rfc2119" title="must">
must
</em>
be
thrown.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a>
object
or
object[]
or
URL
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
The
JSON-LD
object
or
array
of
JSON-LD
objects
to
perform
the
compaction
upon
or
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
referencing
the
JSON-LD
document
to
compact.
</td>
</tr>
<tr>
<td class="prmName">
context
</td>
<td class="prmType">
<code>
<a>
object
or
URL
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
The
context
to
use
when
compacting
the
<code>
input
</code>
;
either
in
the
form
of
an
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
or
as
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
</td>
</tr>
<tr>
<td class="prmName">
callback
</td>
<td class="prmType">
<code>
<a href="#idl-def-JsonLdCallback" class="idlType">
<code>
JsonLdCallback
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
A
callback
that
is
called
when
processing
is
complete
on
the
given
<code>
input
</code>.
</td>
</tr>
<tr>
<td class="prmName">
options
</td>
<td class="prmType">
<code>
<a href="#idl-def-JsonLdOptions" class="idlType">
<code>
JsonLdOptions
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptTrue">
✔
</td>
<td class="prmDesc">
A
set
of
options
that
<em class="rfc2119" title="may">
may
</em>
affect
the
expansion
algorithm
such
as,
e.g.,
the
input
document's
base
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
This
also
includes
<code>
optimize
</code>,
which
if
set
will
cause
processor-specific
optimization.
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
void
</a>
</code>
</div>
</dd>
<dt id="widl-JsonLdProcessor-expand-void-object-or-object---or-URL-input-object-or-URL-context-JsonLdCallback-callback-JsonLdOptions-options">
<code>
expand
</code>
</dt>
<dd>
<a href="#expansion">
Expands
</a>
the
given
<code>
input
</code>
according
to
the
steps
in
the
<a href="#expansion-algorithm">
Expansion
Algorithm
</a>.
The
<code>
input
</code>
<em class="rfc2119" title="must">
must
</em>
be
copied,
expanded
and
returned
if
there
are
no
errors.
If
the
expansion
fails,
an
appropriate
exception
<em class="rfc2119" title="must">
must
</em>
be
thrown.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a>
object
or
object[]
or
URL
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
The
JSON-LD
object
or
array
of
JSON-LD
objects
to
perform
the
expansion
upon
or
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
referencing
the
JSON-LD
document
to
expand.
</td>
</tr>
<tr>
<td class="prmName">
context
</td>
<td class="prmType">
<code>
<a>
<del class="diff-old">ObjectOrURL
✔
✘
An
optional
external
context
to
use
additionally
to
the
context
embedded
in
input
when
expanding
the
input
.
callback
JsonLdCallback
✘
✘
A
callback
that
is
called
when
processing
is
complete
on
the
given
input
.
options
JsonLdOptions
✘
✔
A
set
of
options
that
may
affect
the
expansion
algorithm
such
as,
e.g.,
the
input
document's
base
IRI
.
Return
type:
void
flatten
Flattens
the
given
input
according
to
the
steps
in
the
Flattening
Algorithm
.
The
input
must
be
flattened
and
returned
if
there
are
no
errors.
If
the
flattening
fails,
an
appropriate
exception
must
be
thrown.
It
is
still
being
discussed
if
the
flatten()
method
should
be
added
or
not.
See
ISSUE-109
.
Parameter
Type
Nullable
Optional
Description
input
</del>
object
or
<del class="diff-old">object[]
or
</del>
URL
</a>
</code>
</td>
<del class="diff-old">✘
✘
The
JSON-LD
object
or
array
of
JSON-LD
objects
to
flatten
or
an
IRI
referencing
the
JSON-LD
document
to
flatten.
graph
string
or
URL
✘
✘
The
graph
in
the
document
that
should
be
flattened.
To
return
the
default
graph
@default
has
to
be
passed,
for
the
merged
graph
@merged
and
for
any
other
graph
the
IRI
identifying
the
graph
has
to
be
passed.
The
default
value
is
@merged
.
context
ObjectOrURL
</del>
<td class="prmNullTrue">
✔
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
An
optional
external
context
to
use
additionally
to
the
context
embedded
in
<code>
input
</code>
when
expanding
the
<code>
input
</code>.
</td>
</tr>
<tr>
<td class="prmName">
callback
</td>
<td class="prmType">
<code>
<a href="#idl-def-JsonLdCallback" class="idlType">
<code>
JsonLdCallback
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
A
callback
that
is
called
when
processing
is
complete
on
the
given
<code>
input
</code>.
</td>
</tr>
<tr>
<td class="prmName">
options
</td>
<td class="prmType">
<code>
<a href="#idl-def-JsonLdOptions" class="idlType">
<code>
JsonLdOptions
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptTrue">
✔
</td>
<td class="prmDesc">
A
set
of
options
that
<em class="rfc2119" title="may">
may
</em>
affect
the
expansion
algorithm
such
as,
e.g.,
the
input
document's
base
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
void
</a>
</code>
</div>
</dd>
<del class="diff-old">frame
Frames
the
given
input
using
the
frame
according
to
the
steps
in
the
Framing
Algorithm
.
The
input
is
used
to
build
the
framed
output
and
is
returned
if
there
are
no
errors.
If
there
are
no
matches
for
the
frame,
null
must
be
returned.
Exceptions
must
be
thrown
if
there
are
errors.
Parameter
Type
Nullable
Optional
Description
input
object
or
object[]
or
URL
✘
✘
The
JSON-LD
object
or
array
of
JSON-LD
objects
to
perform
the
framing
upon
or
an
IRI
referencing
the
JSON-LD
document
to
frame.
frame
object
or
URL
✘
✘
The
frame
to
use
when
re-arranging
the
data
of
input
;
either
in
the
form
of
an
JSON
object
or
as
IRI
.
callback
JsonLdCallback
✘
✘
A
callback
that
is
called
when
processing
is
complete
on
the
given
input
.
options
JsonLdOptions
✘
✔
A
set
of
options
that
may
affect
the
framing
algorithm
such
as,
e.g.,
the
input
document's
base
IRI
.
Return
type:
void
</del>
<dt id="widl-JsonLdProcessor-fromRDF-void-QuadArray-input-JsonLdCallback-callback-JsonLdOptions-options">
<code>
fromRDF
</code>
</dt>
<dd>
Creates
a
JSON-LD
document
given
an
set
of
<a class="datatype idlType" title="quad" href="#idl-def-quad">
<code>
Quads
</code>
</a>.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
[]
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
<del class="diff-old">An
</del>
<ins class="diff-chg">A
</ins><a class="tref internalDFN" title="dataset" href="#dfn-dataset"><ins class="diff-chg">
dataset
</ins></a><ins class="diff-chg">
represented
as
an
</ins>
array
of
<del class="diff-old">RDF
quads.
</del>
<a class="datatype idlType" title="quad" href="#idl-def-quad">
<code>
<ins class="diff-chg">Quads
</ins></code></a>.
</td>
</tr>
<tr>
<td class="prmName">
callback
</td>
<td class="prmType">
<code>
<a href="#idl-def-JsonLdCallback" class="idlType">
<code>
JsonLdCallback
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
A
callback
that
is
called
when
processing
is
complete
on
the
given
<code>
input
</code>.
</td>
</tr>
<tr>
<td class="prmName">
options
</td>
<td class="prmType">
<code>
<a href="#idl-def-JsonLdOptions" class="idlType">
<code>
JsonLdOptions
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptTrue">
✔
</td>
<td class="prmDesc">
A
set
of
options
that
will
affect
the
algorithm.
This
includes
<code>
notType
</code>,
which
if
set
to
<a class="tref internalDFN" title="true" href="#dfn-true">
true
</a>
causes
the
resulting
document
to
use
<code>
rdf:type
</code>
as
a
property,
instead
of
<code>
@type
</code>.
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
void
</a>
</code>
</div>
</dd>
<dt id="widl-JsonLdProcessor-toRDF-void-object-or-object---or-URL-input-QuadCallback-callback-JsonLdOptions-options">
<code>
toRDF
</code>
</dt>
<dd>
Processes
the
<code>
input
</code>
according
to
the
<a href="#convert-to-rdf-algorithm">
Convert
to
RDF
Algorithm
</a>,
calling
the
provided
<code>
callback
</code>
for
each
<a class="datatype idlType" title="Quad" href="#idl-def-Quad">
<code>
Quad
</code>
</a>
generated.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
input
</td>
<td class="prmType">
<code>
<a>
object
or
object[]
or
URL
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
The
JSON-LD
object
or
array
of
JSON-LD
objects
to
convert
to
RDF
or
<del class="diff-old">an
</del>
<ins class="diff-chg">a
</ins><a href="#idl-def-URL" class="idlType">
<del class="diff-old">IRI
</del>
<code>
<ins class="diff-chg">URL
</ins></code>
</a>
referencing
the
JSON-LD
document
to
convert
to
RDF.
</td>
</tr>
<tr>
<td class="prmName">
callback
</td>
<td class="prmType">
<code>
<a href="#idl-def-QuadCallback" class="idlType">
<code>
QuadCallback
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
A
callback
that
is
called
when
a
<a class="datatype idlType" title="Quad" href="#idl-def-Quad">
<code>
Quad
</code>
</a>
is
created
from
processing
the
given
<code>
input
</code>.
</td>
</tr>
<tr>
<td class="prmName">
options
</td>
<td class="prmType">
<code>
<a href="#idl-def-JsonLdOptions" class="idlType">
<code>
JsonLdOptions
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptTrue">
✔
</td>
<td class="prmDesc">
A
set
of
options
that
<em class="rfc2119" title="may">
may
</em>
affect
the
conversion
to
RDF
such
as,
e.g.,
the
input
document's
base
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
void
</a>
</code>
</div>
</dd>
</dl>
</div>
</div>
<div id="callbacks" class="section">
<h3>
<span class="secno">
<del class="diff-old">2.2
</del>
<ins class="diff-chg">3.3
</ins>
</span>
Callbacks
</h3>
<div id="jsonldcallback" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.2.1
</del>
<ins class="diff-chg">3.3.1
</ins>
</span>
JsonLdCallback
</h4>
<p>
The
<a href="#idl-def-JsonLdCallback" class="idlType">
<code>
JsonLdCallback
</code>
</a>
is
used
to
return
a
processed
JSON-LD
representation
as
the
result
of
processing
an
API
method.
</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-JsonLdCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">JsonLdCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JsonLdCallback-jsonLd-void-object-or-objectArray-jsonld">jsonLd</a></span> (<span class="idlParam"><span class="idlParamType"><a>object or object</a>[]</span> <span class="idlParamName">jsonld</span></span>);</span>
};</span>
</pre>
<div id="methods-1" class="section">
<h2>
<span class="secno">
<del class="diff-old">2.2.1.1
</del>
<ins class="diff-chg">3.3.1.1
</ins>
</span>
Methods
</h2>
<dl class="methods">
<dt id="widl-JsonLdCallback-jsonLd-void-object-or-objectArray-jsonld">
<code>
jsonLd
</code>
</dt>
<dd>
This
callback
is
invoked
when
processing
is
complete.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
jsonld
</td>
<td class="prmType">
<code>
<a>
<del class="diff-old">ObjectOrObjectArray
</del>
<ins class="diff-chg">object
or
object
</ins>
</a>
<ins class="diff-chg">[]
</ins>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
The
processed
JSON-LD
document.
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
void
</a>
</code>
</div>
</dd>
</dl>
</div>
</div>
<div id="quadcallback" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.2.2
</del>
<ins class="diff-chg">3.3.2
</ins>
</span>
QuadCallback
</h4>
<p>
The
<a href="#idl-def-QuadCallback" class="idlType">
<code>
QuadCallback
</code>
</a>
is
called
whenever
the
processor
generates
a
quad
during
the
<code>
quad()
</code>
call.
</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-QuadCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">QuadCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-QuadCallback-quad-void-Quad-quad">quad</a></span> (<span class="idlParam"><span class="idlParamType"><a href="#idl-def-Quad" class="idlType"><code>Quad</code></a></span> <span class="idlParamName">quad</span></span>);</span>
};</span>
</pre>
<div id="methods-2" class="section">
<h2>
<span class="secno">
<del class="diff-old">2.2.2.1
</del>
<ins class="diff-chg">3.3.2.1
</ins>
</span>
Methods
</h2>
<dl class="methods">
<dt id="widl-QuadCallback-quad-void-Quad-quad">
<code>
quad
</code>
</dt>
<dd>
This
callback
is
invoked
whenever
a
quad
is
generated
by
the
processor.
<table class="parameters">
<tr>
<th>
Parameter
</th>
<th>
Type
</th>
<th>
Nullable
</th>
<th>
Optional
</th>
<th>
Description
</th>
</tr>
<tr>
<td class="prmName">
quad
</td>
<td class="prmType">
<code>
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
</code>
</td>
<td class="prmNullFalse">
✘
</td>
<td class="prmOptFalse">
✘
</td>
<td class="prmDesc">
The
quad.
</td>
</tr>
</table>
<div>
<em>
Return
type:
</em>
<code>
<a>
void
</a>
</code>
</div>
</dd>
</dl>
</div>
</div>
</div>
<div id="data-structures" class="section">
<h3>
<span class="secno">
<del class="diff-old">2.3
</del>
<ins class="diff-chg">3.4
</ins>
</span>
Data
Structures
</h3>
<p>
This
section
describes
datatype
definitions
used
within
the
JSON-LD
API.
</p>
<div id="url" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.3.1
</del>
<ins class="diff-chg">3.4.1
</ins>
</span>
URL
</h4>
<p>
The
<a href="#idl-def-URL" class="idlType">
<code>
URL
</code>
</a>
datatype
is
a
string
representation
of
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
</p>
<pre class="idl">
<span class="idlTypedef" id="idl-def-URL">
typedef
<span class="idlTypedefType">
<a>
DOMString
</a>
</span>
<span class="idlTypedefID">
URL
</span>
;
</span>
</pre>
<div class="idlTypedefDesc">
This
datatype
indicates
that
the
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
is
interpreted
as
a
Universal
Resource
Locator
identifying
a
document,
which
when
parsed
as
JSON
yields
either
a
<code>
JSON
object
</code>
or
<code>
array
</code>.
</div>
</div>
<div id="jsonldoptions" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.3.2
</del>
<ins class="diff-chg">3.4.2
</ins>
</span>
JsonLdOptions
</h4>
<p>
The
<a href="#idl-def-JsonLdOptions" class="idlType">
<code>
JsonLdOptions
</code>
</a>
type
is
used
to
<del class="diff-old">convery
</del>
<ins class="diff-chg">convert
</ins>
a
set
of
options
to
an
interface
method.
</p>
<pre class="idl">
<span class="idlTypedef" id="idl-def-JsonLdOptions">
typedef
<span class="idlTypedefType">
<a>
object
</a>
</span>
<span class="idlTypedefID">
JsonLdOptions
</span>
;
</span>
</pre>
<div class="idlTypedefDesc">
<dt>
<a href="#idl-def-URL" class="idlType">
<code>
URL
</code>
</a>
base
</dt>
<dd>
The
Base
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
to
use
when
expanding
the
document.
This
overrides
the
value
of
<em>
input
</em>
if
it
is
a
<a href="#idl-def-URL" class="idlType">
<code>
URL
</code>
</a>
or
if
it
is
a
<code>
object
</code>
or
<code>
object[]
</code>.
</dd>
<dt>
boolean
optimize
</dt>
<dd>
If
set
to
<code>
true
</code>,
the
JSON-LD
processor
is
allowed
to
optimize
the
output
of
the
<a href="#compaction-algorithm">
Compaction
Algorithm
</a>
to
produce
even
compacter
representations.
The
algorithm
for
compaction
optimization
is
beyond
the
scope
of
this
specification
and
thus
not
defined.
Consequently,
different
implementations
<em class="rfc2119" title="may">
may
</em>
implement
different
optimization
algorithms.
</dd>
<dt>
boolean
noType
</dt>
<dd>
If
set
to
<code>
true
</code>,
the
JSON-LD
processor
will
not
use
the
<code>
@type
</code>
property
when
generating
the
output,
and
will
use
the
expanded
<code>
rdf:type
</code>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
as
the
property
instead
of
<code>
@type
</code>.
</dd>
</div>
</div>
<p>
The
following
data
structures
are
used
for
representing
data
about
RDF
quads.
They
are
used
for
normalization,
<a>
fromRDF
</a>,
and
from
<a>
toRDF
</a>
interfaces.
</p>
<div id="quad" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.3.3
</del>
<ins class="diff-chg">3.4.3
</ins>
</span>
Quad
</h4>
<p>
The
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
interface
represents
an
RDF
Quad.
See
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">
RDF-CONCEPTS
</a>
</cite>
]
definition
for
<cite>
<a href="http://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple">
RDF
triple
</a>
</cite>,
which
most
closely
aligns
to
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>.
</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-Quad">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">Quad</span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-subject">subject</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-predicate">predicate</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span>  <span class="idlAttrName"><a href="#widl-Quad-object">object</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-Node" class="idlType"><code>Node</code></a>?</span> <span class="idlAttrName"><a href="#widl-Quad-graphName">graphName</a></span>;</span>
};</span>
</pre>
<div id="attributes" class="section">
<h2>
<span class="secno">
<del class="diff-old">2.3.3.1
</del>
<ins class="diff-chg">3.4.3.1
</ins>
</span>
Attributes
</h2>
<dl class="attributes">
<dt id="widl-Quad-graphName">
<code>
<del class="diff-old">name
</del>
<ins class="diff-chg">graphName
</ins>
</code>
of
type
<span class="idlAttrType">
<a href="#idl-def-Node" class="idlType">
<code>
Node
</code>
</a>
</span>,
readonly,
nullable
</dt>
<dd>
<del class="diff-old">The
</del>
<ins class="diff-chg">If
present,
the
</ins>
name
associated
with
the
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
identifying
it
as
a
member
of
a
<del class="diff-old">named
graph.
If
the
attribute
is
present,
it
indicates
that
this
quad
is
a
member
of
a
</del>
<a class="tref internalDFN" title="named_graph" href="#dfn-named_graph">
named
graph
<del class="diff-old">associated
with
name
.
</del>
</a>.
If
it
is
missing,
the
quad
is
a
member
of
the
<a class="tref internalDFN" title="default_graph" href="#dfn-default_graph">
default
graph
<del class="diff-old">.
</del>
</a>.
<div class="issue">
<div class="issue-title">
<span>
<ins class="diff-new">Issue
4
</ins></span></div><div class="">
This
element
is
at
risk,
and
may
be
removed.
</div>
</div>
</dd>
<dt id="widl-Quad-object">
<code>
object
</code>
of
type
<span class="idlAttrType">
<a href="#idl-def-Node" class="idlType">
<code>
Node
</code>
</a>
</span>,
readonly
</dt>
<dd>
The
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
associated
with
the
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>.
</dd>
<dt id="widl-Quad-predicate">
<code>
<del class="diff-old">property
</del>
<ins class="diff-chg">predicate
</ins>
</code>
of
type
<span class="idlAttrType">
<a href="#idl-def-Node" class="idlType">
<code>
Node
</code>
</a>
</span>,
readonly
</dt>
<dd>
The
<del class="diff-old">property
</del>
<ins class="diff-chg">predicate
</ins>
associated
with
the
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>.
<ins class="diff-new">Within
JSON-LD,
an
</ins><dfn title="rdf_predicate" id="dfn-rdf_predicate"><ins class="diff-new">
RDF
predicate
</ins></dfn><ins class="diff-new">
is
refered
to
as
a
</ins><a class="tref internalDFN" title="property" href="#dfn-property"><ins class="diff-new">
property
</ins></a>
</dd>
<dt id="widl-Quad-subject">
<code>
subject
</code>
of
type
<span class="idlAttrType">
<a href="#idl-def-Node" class="idlType">
<code>
Node
</code>
</a>
</span>,
readonly
</dt>
<dd>
The
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
associated
with
the
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>.
</dd>
</dl>
</div>
</div>
<div id="node" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.3.4
</del>
<ins class="diff-chg">3.4.4
</ins>
</span>
Node
</h4>
<p>
<a class="datatype idlType" title="Node" href="#idl-def-Node">
<code>
Node
</code>
</a>
is
the
base
class
of
<a class="datatype idlType" title="IRI" href="#idl-def-IRI">
<code>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</code>
</a>,
<a class="datatype idlType" title="BlankNode" href="#idl-def-BlankNode">
<code>
BlankNode
</code>
</a>,
and
<a class="datatype idlType" title="Literal" href="#idl-def-Literal">
<code>
Literal
</code>
</a>.
<del class="diff-old">    ]
interface  {
};
2.3.4.1
Attributes
interfaceName
of
type
DOMString
,
readonly
Provides
access
to
the
string
name
of
</del>
<ins class="diff-chg">It
is
</ins>
the
<del class="diff-old">current
interface,
normally
one
of
&quot;
IRI
&quot;
,
&quot;BlankNode&quot;
or
&quot;Literal&quot;
.
This
method
serves
to
disambiguate
instances
of
Node
which
are
otherwise
identical,
such
as
IRI
and
BlankNode
.
nominalValue
of
type
DOMString
,
readonly
The
nominalValue
</del>
<ins class="diff-chg">IDL
representation
</ins>
of
<del class="diff-old">an
Node
</del>
<ins class="diff-chg">a
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins>
</a>
<del class="diff-old">is
refined
by
each
interface
which
extends
Node
</del>
<a class="tref internalDFN" title="node" href="#dfn-node">
<ins class="diff-chg">node
</ins>
</a>.
</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-Node">[<span class="extAttr">NoInterfaceObject</span>]
<ins class="diff-chg">interface <span class="idlInterfaceID">Node</span> {
};</span>
</ins></pre>
</div>
<div id="iri" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.3.5
</del>
<ins class="diff-chg">3.4.5
</ins>
</span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</h4>
<p>
A
<a class="tref internalDFN" title="node" href="#dfn-node">
node
<del class="diff-old">identified
by
</del>
</a>
<ins class="diff-chg">that
is
</ins>
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
<del class="diff-old">IRIs
are
defined
by
International
Resource
Identifier
[
IRI
].
See
[
RDF-CONCEPTS
]
definition
for
IRI
.
</del>
</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-IRI">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">IRI</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span> <span class="idlAttrName"><a href="#widl-IRI-value">value</a></span>;</span>
};</span>
</pre>
<div id="attributes-1" class="section">
<h2>
<span class="secno">
<del class="diff-old">2.3.5.1
</del>
<ins class="diff-chg">3.4.5.1
</ins>
</span>
Attributes
</h2>
<dl class="attributes">
<dt id="widl-IRI-value">
<code>
<del class="diff-old">nominalValue
</del>
<ins class="diff-chg">value
</ins>
</code>
of
type
<span class="idlAttrType">
<a>
DOMString
</a>
</span>,
readonly
</dt>
<dd>
The
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
identifier
of
the
<del class="diff-old">node.
</del>
<a class="tref internalDFN" title="node" href="#dfn-node">
<ins class="diff-chg">node
</ins></a><ins class="diff-chg">
as
a
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-UNICODE"><ins class="diff-chg">
UNICODE
</ins></a></cite><ins class="diff-chg">
]
string.
</ins>
</dd>
</dl>
</div>
</div>
<div id="blank-node" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.3.6
</del>
<ins class="diff-chg">3.4.6
</ins>
</span>
<dfn title="blank_node" id="dfn-blank_node">
Blank
Node
</dfn>
</h4>
<p>
A
<del class="diff-old">BlankNode
</del>
<a class="tref internalDFN" title="node" href="#dfn-node">
<ins class="diff-chg">node
</ins>
</a>
<del class="diff-old">is
</del>
<ins class="diff-chg">in
the
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a><ins class="diff-chg">
that
does
not
contain
</ins>
a
<del class="diff-old">reference
to
an
unnamed
resource
(one
for
which
an
IRI
may
</del>
<ins class="diff-chg">de-reference-able
identifier
because
it
is
either
ephemeral
in
nature
or
does
</ins>
not
<ins class="diff-new">contain
information
that
needs
to
</ins>
be
<del class="diff-old">known),
and
may
be
used
in
a
</del>
<ins class="diff-chg">linked
to
from
outside
of
the
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a>.<ins class="diff-chg">
A
blank
node
is
assigned
an
identifier
starting
with
the
prefix
</ins>
<code>
<del class="diff-old">Quad
</del>
<ins class="diff-chg">_:
</ins>
</code>
<del class="diff-old">as
a
</del>
<ins class="diff-chg">and
an
implementation
dependent,
auto-generated
suffix
that
is
</ins>
unique
<del class="diff-old">reference
</del>
to
<del class="diff-old">that
unnamed
node.
See
[
RDF-CONCEPTS
]
definition
for
</del>
<ins class="diff-chg">all
information
associated
with
the
particular
</ins>
blank
<del class="diff-old">node
.
</del>
<ins class="diff-chg">node.
</ins>
</p>
    <pre class="idl"><span class="idlInterface" id="idl-def-BlankNode">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">BlankNode</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span> <span class="idlAttrName"><a href="#widl-BlankNode-identifier">identifier</a></span>;</span>
};</span>
</pre>
<div id="attributes-2" class="section">
<h2>
<span class="secno">
<del class="diff-old">2.3.6.1
</del>
<ins class="diff-chg">3.4.6.1
</ins>
</span>
Attributes
</h2>
<dl class="attributes">
<dt id="widl-BlankNode-identifier">
<code>
<del class="diff-old">nominalValue
</del>
<ins class="diff-chg">identifier
</ins>
</code>
of
type
<span class="idlAttrType">
<a>
DOMString
</a>
</span>,
readonly
</dt>
<dd>
The
temporary
identifier
of
the
<del class="diff-old">BlankNode
</del>
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
<ins class="diff-chg">blank
node
</ins>
</a>.
The
<del class="diff-old">nominalValue
</del>
<code>
<ins class="diff-chg">identifier
</ins></code>
<em class="rfc2119" title="must not">
must
not
</em>
be
relied
upon
in
any
way
between
two
separate
processing
runs
of
the
same
<ins class="diff-new">document
or
with
a
different
</ins>
document.
</dd>
</dl>
</div>
<div class="note">
<div class="note-title">
<span>
<ins class="diff-chg">Note
</ins></span></div><p class="">
Developers
and
authors
must
not
assume
that
the
<del class="diff-old">nominalValue
</del>
<ins class="diff-chg">value
</ins>
of
a
<del class="diff-old">BlankNode
</del>
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
<ins class="diff-chg">blank
node
</ins>
</a>
will
remain
the
same
between
two
processing
runs.
<a href="#idl-def-BlankNode" class="idlType">
<code>
BlankNode
</code>
</a>
<del class="diff-old">nominalValues
</del>
<ins class="diff-chg">values
</ins>
are
only
valid
for
the
most
recent
processing
run
on
the
document.
<a href="#idl-def-BlankNode" class="idlType">
<code>
<del class="diff-old">BlankNodes
</del>
<ins class="diff-chg">BlankNode
</ins>
</code>
</a>
<del class="diff-old">nominalValues
</del>
<ins class="diff-chg">values
</ins>
will
often
be
generated
differently
by
different
processors.
</p>
</div>
<div class="note">
<div class="note-title">
<span>
<ins class="diff-chg">Note
</ins></span></div><p class="">
Implementers
<em class="rfc2119" title="must">
must
</em>
ensure
that
<a href="#idl-def-BlankNode" class="idlType">
<code>
BlankNode
</code>
</a>
<del class="diff-old">nominalValues
</del>
<ins class="diff-chg">values
</ins>
are
unique
within
the
current
environment,
two
<a class="datatype idlType" title="blanknode" href="#idl-def-blanknode">
<code>
BlankNodes
</code>
</a>
are
considered
equal
if,
and
only
if,
their
<del class="diff-old">nominalValues
</del>
<ins class="diff-chg">values
</ins>
are
strictly
equal.
</p>
</div>
</div>
<div id="literal" class="section">
<h4>
<span class="secno">
<del class="diff-old">2.3.7
</del>
<ins class="diff-chg">3.4.7
</ins>
</span>
Literal
</h4>
<p>
Literals
represent
values
such
as
numbers,
dates
and
strings
in
RDF
data.
A
<a class="datatype idlType" title="Literal" href="#idl-def-Literal">
<code>
Literal
</code>
</a>
is
comprised
of
three
attributes:
</p>
<ul>
<li>
a
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form
</ins>
of
the
<code>
<del class="diff-old">nominalValue
</del>
<ins class="diff-chg">value
</ins>
</code>
</li>
<li>
an
optional
<code>
language
</code>
<del class="diff-old">represented
by
a
string
token
</del>
<ins class="diff-chg">tag
</ins>
</li>
<li>
<del class="diff-old">an
optional
</del>
<ins class="diff-chg">a
</ins>
<code>
datatype
</code>
specified
by
an
<a class="datatype idlType" title="IRI" href="#idl-def-IRI">
<code>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</code>
</a>
</li>
</ul>
<p>
Literals
representing
plain
text
in
a
natural
language
may
have
a
<code>
language
</code>
<del class="diff-old">attribute
</del>
<ins class="diff-chg">tag
</ins>
specified
by
a
<del class="diff-old">text
</del>
string
token,
as
specified
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-BCP47">
BCP47
</a>
</cite>
],
normalized
to
lowercase
(e.g.,
<code>
'en'
</code>,
<code>
'fr'
</code>,
<code>
'en-gb'
</code>
).
They
<del class="diff-old">may
</del>
also
have
a
datatype
attribute
such
as
<code>
xsd:string
</code>.
<ins class="diff-new">If
unspecified,
the
</ins><code><ins class="diff-new">
datatype
</ins></code><ins class="diff-new">
defaults
to
</ins><code><ins class="diff-new">
xsd:string
</ins></code>.
</p>
<p>
Literals
representing
values
with
a
specific
datatype,
such
as
the
integer
72,
may
have
a
<code>
datatype
</code>
attribute
specified
in
the
form
of
a
<a href="#idl-def-IRI" class="idlType">
<code>
IRI
</code>
</a>
(e.g.,
<code>
<del class="diff-old">&lt;http://www.w3.org/2001/XMLSchema#integer&gt;
</del>
<ins class="diff-chg">xsd:integer
</ins>
</code>
).
</p>
<p>
See[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">
RDF-CONCEPTS
</a>
</cite>
]
definition
for
<cite>
<a href="http://www.w3.org/TR/rdf11-concepts/#dfn-literal">
literal
</a>
</cite>.
</p>
      <pre class="idl"><span class="idlInterface" id="idl-def-Literal">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">Literal</span> : <span class="idlSuperclass"><a href="#idl-def-Node" class="idlType"><code>Node</code></a></span> {
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a></span>  <span class="idlAttrName"><a href="#widl-Literal-value">value</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a>DOMString</a>?</span> <span class="idlAttrName"><a href="#widl-Literal-language">language</a></span>;</span>
<span class="idlAttribute">    readonly attribute <span class="idlAttrType"><a href="#idl-def-IRI" class="idlType"><code>IRI</code></a>?</span>       <span class="idlAttrName"><a href="#widl-Literal-datatype">datatype</a></span>;</span>
};</span>
</pre>
<div id="attributes-3" class="section">
<h2>
<span class="secno">
<del class="diff-old">2.3.7.1
</del>
<ins class="diff-chg">3.4.7.1
</ins>
</span>
Attributes
</h2>
<dl class="attributes">
<dt id="widl-Literal-datatype">
<code>
datatype
</code>
of
type
<span class="idlAttrType">
<a href="#idl-def-IRI" class="idlType">
<code>
IRI
</code>
</a>
</span>,
readonly,
nullable
</dt>
<dd>
An
optional
datatype
identified
by
a
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>.
</dd>
<dt id="widl-Literal-language">
<code>
language
</code>
of
type
<span class="idlAttrType">
<a>
DOMString
</a>
</span>,
readonly,
nullable
</dt>
<dd>
An
optional
language
<del class="diff-old">string
</del>
<ins class="diff-chg">tag
</ins>
as
defined
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-BCP47">
BCP47
</a>
</cite>
],
normalized
to
lowercase.
</dd>
<dt id="widl-Literal-value">
<code>
<del class="diff-old">nominalValue
</del>
<ins class="diff-chg">value
</ins>
</code>
of
type
<span class="idlAttrType">
<a>
DOMString
</a>
</span>,
readonly
</dt>
<dd>
The
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form
</ins>
of
the
<del class="diff-old">Literals
</del>
<ins class="diff-chg">Literal's
</ins>
value.
</dd>
</dl>
</div>
</div>
</div>
</div>
<div id="algorithms" class="section">
<h2>
<span class="secno">
<del class="diff-old">3.
</del>
<ins class="diff-chg">4.
</ins>
</span>
Algorithms
</h2>
<p>
All
algorithms
described
in
this
section
are
intended
to
operate
on
language-native
data
structures.
That
is,
the
serialization
to
a
text-based
JSON
document
isn't
required
as
input
or
output
to
any
of
these
algorithms
and
language-native
data
structures
<em class="rfc2119" title="must">
must
</em>
be
used
where
applicable.
</p>
<del class="diff-old">3.1
Syntax
Tokens
and
Keywords
JSON-LD
specifies
a
number
of
syntax
tokens
and
keyword
s
that
are
using
in
all
algorithms
described
in
this
section:
@context
Used
to
set
the
local
context
.
@id
Sets
the
active
subject.
@language
Used
to
specify
the
language
for
a
literal.
@type
Used
to
set
the
type
of
the
active
subject
or
the
datatype
of
a
literal.
@value
Used
to
specify
the
value
of
a
literal.
@container
Used
to
set
the
container
of
a
particular
value.
@list
Used
to
express
an
ordered
set
of
data.
@set
Used
to
express
an
unordered
set
of
data.
@graph
Used
to
explicitly
express
a
linked
data
graph
.
:
The
separator
for
JSON
keys
and
values
that
use
compact
IRIs
.
@default
Used
in
Framing
to
set
the
default
value
for
an
output
property
when
the
framed
subject
definition
does
not
include
such
a
property.
@explicit
Used
in
Framing
to
override
the
value
of
explicit
inclusion
flag
within
a
specific
frame.
@omitDefault
Used
in
Framing
to
override
the
value
of
omit
default
flag
within
a
specific
frame.
@embed
Used
in
Framing
to
override
the
value
of
object
embed
flag
within
a
specific
frame.
@null
Used
in
Framing
when
a
value
of
null
should
be
returned,
which
would
otherwise
be
removed
when
Compacting
.
All
JSON-LD
tokens
and
keywords
are
case-sensitive.
</del>
<div id="algorithm-terms" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.2
</del>
<ins class="diff-chg">4.1
</ins>
</span>
Algorithm
Terms
</h3>
<dl>
<dt>
<dfn title="initial_context" id="dfn-initial_context">
initial
context
</dfn>
</dt>
<dd>
a
context
that
is
specified
to
the
algorithm
before
processing
begins.
The
contents
of
the
initial
context
is
defined
in
<a href="#appendix-a">
Appendix
<del class="diff-old">B
</del>
<ins class="diff-chg">A
</ins>
</a>.
</dd>
<dt>
<dfn title="active_subject" id="dfn-active_subject">
active
subject
</dfn>
</dt>
<dd>
the
currently
active
subject
that
the
processor
should
use
when
processing.
</dd>
<dt>
<dfn title="active_property" id="dfn-active_property">
active
property
</dfn>
</dt>
<dd>
the
currently
active
property
that
the
processor
should
use
when
processing.
The
active
property
is
represented
in
the
original
lexical
form,
which
is
used
for
finding
coercion
mappings
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</dd>
<dt>
<dfn title="active_object" id="dfn-active_object">
active
object
</dfn>
</dt>
<dd>
the
currently
active
object
that
the
processor
should
use
when
processing.
</dd>
<dt>
<dfn title="active_context" id="dfn-active_context">
active
context
</dfn>
</dt>
<dd>
a
context
that
is
used
to
resolve
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
while
the
processing
algorithm
is
running.
The
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
is
the
context
contained
within
the
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</dd>
<dt>
<del class="diff-old">blank
node
a
blank
node
is
a
resource
which
is
neither
an
IRI
nor
a
literal
.
Blank
nodes
may
be
named
or
unnamed
and
often
take
on
the
role
of
a
variable
that
may
represent
either
an
IRI
or
a
literal
.
</del>
<dfn title="compact_iri" id="dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</dfn>
</dt>
<dd>
a
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is
has
the
form
of
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
</a>
and
<em>
suffix
</em>
and
is
used
as
a
way
of
expressing
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
without
needing
to
define
separate
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
definitions
for
each
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
contained
within
a
common
vocabulary
identified
by
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
</a>.
</dd>
<dt>
<dfn title="local_context" id="dfn-local_context">
local
context
</dfn>
</dt>
<dd>
a
context
that
is
specified
within
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>,
specified
via
the
<code>
@context
</code>
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>.
</dd>
<dt>
<dfn title="processor_state" id="dfn-processor_state">
processor
state
</dfn>
</dt>
<dd>
the
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>,
which
includes
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
The
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
is
managed
as
a
stack
with
elements
from
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
copied
into
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
when
entering
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>.
</dd>
<dt>
<dfn title="json-ld_input" id="dfn-json-ld_input">
JSON-LD
input
</dfn>
</dt>
<dd>
The
JSON-LD
data
structure
that
is
provided
as
input
to
the
algorithm.
</dd>
<dt>
<dfn title="json-ld_output" id="dfn-json-ld_output">
JSON-LD
output
</dfn>
</dt>
<dd>
The
JSON-LD
data
structure
that
is
produced
as
output
by
the
algorithm.
</dd>
<dt>
<dfn title="term" id="dfn-term">
term
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
is
a
short
word
defined
in
a
context
that
<em class="rfc2119" title="may">
may
</em>
be
expanded
to
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
</dd>
<dt>
<dfn title="prefix" id="dfn-prefix">
prefix
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">
prefix
</a>
is
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
that
expands
to
a
vocabulary
base
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>.
It
is
typically
used
along
with
a
<em>
suffix
</em>
to
form
a
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
to
create
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
within
a
vocabulary.
</dd>
<dt>
<del class="diff-old">plain
</del>
<dfn title="language-tagged_literal" id="dfn-language-tagged_literal">
<ins class="diff-chg">language-tagged
</ins>
literal
</dfn>
</dt>
<dd>
A
<del class="diff-old">plain
</del>
<a class="tref internalDFN" title="language-tagged_literal" href="#dfn-language-tagged_literal">
<ins class="diff-chg">language-tagged
</ins>
literal
</a>
is
a
<a class="tref internalDFN" title="literal" href="#dfn-literal">
literal
</a>
without
a
datatype,
<del class="diff-old">possibly
</del>
including
a
language.
<ins class="diff-new">See
</ins><cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-language-tagged-literal"><ins class="diff-new">
languaged-tagged
literal
</ins></a></cite><ins class="diff-new">
in
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS"><ins class="diff-new">
RDF-CONCEPTS
</ins></a></cite><ins class="diff-new">
].
</ins>
</dd>
<dt>
<dfn title="typed_literal" id="dfn-typed_literal">
typed
literal
</dfn>
</dt>
<dd>
A
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
is
a
<a class="tref internalDFN" title="literal" href="#dfn-literal">
literal
</a>
with
an
associated
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
which
indicates
the
literal's
datatype.
<ins class="diff-new">See
</ins><cite><a href="http://www.w3.org/TR/rdf11-concepts/#dfn-typed-literal"><ins class="diff-new">
languaged-tagged
literal
</ins></a></cite><ins class="diff-new">
in
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS"><ins class="diff-new">
RDF-CONCEPTS
</ins></a></cite><ins class="diff-new">
].
</ins>
</dd>
</dl>
</div>
<div id="context-processing" class="section">
<h3 id="context">
<span class="secno">
<del class="diff-old">3.3
</del>
<ins class="diff-chg">4.2
</ins>
</span>
Context
Processing
</h3>
<p>
Processing
of
JSON-LD
data
structure
is
managed
recursively.
During
processing,
each
rule
is
applied
using
information
provided
by
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
Processing
begins
by
pushing
a
new
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
onto
the
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>
stack
and
initializing
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
with
the
<a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">
initial
context
</a>.
If
a
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
encountered,
information
from
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
merged
into
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</p>
<p>
The
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
is
used
for
expanding
properties
and
values
of
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
(or
elements
of
an
array)
using
a
<dfn title="term_mapping" id="dfn-term_mapping">
term
mapping
</dfn>.
It
is
also
used
to
maintain
<dfn title="coercion_mapping" id="dfn-coercion_mapping">
coercion
mapping
</dfn>
s
from
terms
to
datatypes,
<dfn title="language_mapping" id="dfn-language_mapping">
language
mapping
</dfn>
s
from
terms
to
language
codes,
and
<dfn title="list_mapping" id="dfn-list_mapping">
list
mapping
</dfn>
s
and
<dfn title="set_mapping" id="dfn-set_mapping">
set
mapping
</dfn>
s
for
terms.
Processors
<em class="rfc2119" title="must">
must
</em>
use
the
lexical
form
of
the
property
when
creating
a
mapping,
as
lookup
is
performed
on
lexical
<del class="diff-old">representations,
</del>
<ins class="diff-chg">forms,
</ins>
not
expanded
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
representations.
</p>
<p>
A
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
is
identified
within
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
having
a
<code>
@context
</code>
property
with
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
or
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
value.
When
processing
a
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>,
special
processing
rules
apply:
</p>
<ol class="algorithm">
<li>
Create
a
new,
empty
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
</li>
<li>
Let
<em>
context
</em>
be
the
value
of
<code>
@context
</code>
<ol class="algorithm">
<li id="process-context">
If
<em>
context
</em>
equals
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
reset
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
to
the
<a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">
initial
context
</a>.
</li>
<li>
If
<em>
context
</em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
process
each
element
as
<em>
context
</em>
in
order
by
starting
at
<a href="#process-context">
Step
2.1
</a>.
</li>
<li>
If
<em>
context
</em>
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
it
<em class="rfc2119" title="must">
must
</em>
have
a
lexical
form
of
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
<ol class="algorithm">
<li>
Dereference
<em>
context
</em>.
</li>
<li>
If
the
resulting
document
is
a
JSON
document,
extract
the
top-level
<code>
@context
</code>
element
using
the
JSON
Pointer
&quot;/@context&quot;
as
described
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-JSON-POINTER">
JSON-POINTER
</a>
</cite>
].
Set
<em>
context
</em>
to
the
extracted
content
and
process
it
by
starting
at
<a href="#process-context">
Step
2.1
</a>.
</li>
</ol>
</li>
<li>
If
<em>
context
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>,
perform
the
following
steps:
<ol class="algorithm">
<li>
If
<em>
context
</em>
has
a
<code>
@language
</code>
property,
it
<em class="rfc2119" title="must">
must
</em>
have
a
value
of
a
simple
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>
or
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>.
Add
the
language
to
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
</li>
<li id="object-context">
Otherwise,
for
each
property
in
<em>
context
</em>
perform
the
following
steps:
<ol class="algorithm">
<li>
If
the
property's
value
is
a
simple
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
determine
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
mapping
value
by
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
associated
value.
If
the
result
of
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
mapping
is
an
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
merge
the
property
into
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
<a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">
term
mapping
</a>,
unless
the
property
is
a
JSON-LD
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>,
in
which
case
throw
an
exception.
</li>
<li>
Otherwise,
if
the
property's
value
is
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>
remove
mapping,
coercion,
container
and
language
information
associated
with
property
from
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
</li>
<li>
Otherwise,
the
<em>
property
</em>
's
<em>
value
</em>
<em class="rfc2119" title="must">
must
</em>
be
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>.
<ol class="algorithm">
<li>
If
the
<em>
property
</em>
is
a
JSON-LD
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>
and
the
value
has
<code>
@id
</code>,
<code>
@language
</code>
or
<code>
@type
</code>
properties,
throw
an
exception.
<div class="issue">
<div class="issue-title">
<span>
<ins class="diff-new">Issue
5
</ins></span></div><div class="">
Undecided
if
<code>
@type
</code>
or
<code>
@graph
</code>
can
take
a
<code>
@container
</code>
with
<code>
@set
</code>.
</div>
</div>
</li>
<li>
If
the
<em>
property
</em>
has
the
form
of
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>,
its
<em>
value
</em>
<em class="rfc2119" title="must">
must
</em>
have
an
<code>
@id
</code>
property
with
a
string
value
which
<em class="rfc2119" title="must">
must
</em>
have
the
form
of
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>,
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
or
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
Determine
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
mapping
by
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
associated
value.
If
the
result
of
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
mapping
is
an
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
merge
the
<em>
property
</em>
into
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
<a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">
term
mapping
</a>.
</li>
<li>
If
the
<em>
property
</em>
has
the
form
of
of
a
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
or
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
the
<em>
value
</em>
<em class="rfc2119" title="may">
may
</em>
have
a
<code>
@id
</code>
property
with
a
string
value
which
<em class="rfc2119" title="must">
must
</em>
have
the
form
of
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>,
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
or
absolute
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
Determine
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
mapping
by
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
associated
value.
If
the
result
of
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
mapping
is
an
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
merge
the
<em>
property
</em>
into
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
<a class="tref internalDFN" title="term_mapping" href="#dfn-term_mapping">
term
mapping
</a>.
</li>
<li>
If
the
<em>
value
</em>
has
a
<code>
@type
</code>
property,
its
value
<em class="rfc2119" title="must">
must
</em>
have
the
form
of
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>,
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
or
the
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>
<code>
@id
</code>.
Determine
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
by
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
associated
value.
If
the
result
of
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
mapping
is
an
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
or
<code>
@id
</code>,
merge
into
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
<a class="tref internalDFN" title="coercion_mapping" href="#dfn-coercion_mapping">
coercion
mapping
</a>
using
the
lexical
value
of
the
<em>
property
</em>.
</li>
<li>
If
the
<em>
value
</em>
has
a
<code>
@container
</code>
property,
its
value
<em class="rfc2119" title="must">
must
</em>
be
<code>
@list
</code>
or
<code>
@set
</code>.
Merge
the
<a class="tref internalDFN" title="list_mapping" href="#dfn-list_mapping">
list
mapping
</a>
or
<a class="tref internalDFN" title="set_mapping" href="#dfn-set_mapping">
set
mapping
</a>
into
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
using
the
lexical
value
of
the
<em>
property
</em>.
</li>
<li>
If
the
<em>
value
</em>
has
a
<code>
@language
</code>
property
but
no
<code>
@type
</code>
property,
the
value
of
the
<code>
@language
</code>
property
<em class="rfc2119" title="must">
must
</em>
be
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>
or
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>.
Merge
the
<a class="tref internalDFN" title="language_mapping" href="#dfn-language_mapping">
language
mapping
</a>
into
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
using
the
lexical
value
of
the
<em>
property
</em>.
</li>
</ol>
</li>
<li>
Merge
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>
into
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</li>
<li>
Repeat
<a href="#object-context">
Step
2.4.2
</a>
until
no
entries
are
added
to
the
<a class="tref internalDFN" title="local_context" href="#dfn-local_context">
local
context
</a>.
</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
</ol>
<div class="note">
<div class="note-title">
<span>
<ins class="diff-chg">Note
</ins></span></div><p class="">
It
can
be
difficult
to
distinguish
between
a
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
and
an
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
as
a
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
may
seem
to
be
a
valid
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
<em>
scheme
</em>.
When
performing
repeated
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
expansion,
a
term
used
as
a
prefix
may
not
have
a
valid
mapping
due
to
dependencies
in
resolving
term
definitions.
By
continuing
<a href="#object-context">
Step
2.3.2
</a>
until
no
changes
are
made,
mappings
to
IRIs
created
using
an
undefined
term
prefix
will
eventually
resolve
to
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
s.
</p>
</div>
<div class="issue">
<div class="issue-title">
<span>
<ins class="diff-chg">Issue
6
</ins></span></div><p class="">
<a href="https://github.com/json-ld/json-ld.org/issues/43">
Issue
43
</a>
concerns
performing
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
expansion
in
the
key
position
of
a
context
definition.
</p>
</div>
</div>
<div id="iri-expansion" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.4
</del>
<ins class="diff-chg">4.3
</ins>
</span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</h3>
<p>
Keys
and
some
values
are
evaluated
to
produce
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
This
section
defines
an
algorithm
for
transforming
a
value
representing
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
into
an
actual
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>.
</p>
<p>
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
s
may
be
represented
as
an
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
or
a
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>.
</p>
<p>
An
<dfn title="absolute_iri" id="dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</dfn>
is
defined
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC3987">
RFC3987
</a>
</cite>
]
containing
a
<em>
scheme
</em>
along
with
<em>
path
</em>
and
optional
<em>
query
</em>
and
fragment
segments.
A
<dfn title="relative_iri" id="dfn-relative_iri">
relative
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</dfn>
is
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
that
is
relative
some
other
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
;
in
the
case
of
JSON-LD
this
is
the
base
location
of
the
document.
</p>
<p>
The
algorithm
for
generating
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
is:
</p>
<ol class="algorithm">
<li>
If
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
contains
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
mapping
for
the
value
using
a
case-sensitive
comparison,
use
the
mapped
value
as
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>.
</li>
<li>
Otherwise,
split
the
value
into
a
<em>
prefix
</em>
and
<em>
suffix
</em>
from
the
first
occurrence
of
':'.
</li>
<li>
If
the
prefix
is
a
'_'
(underscore),
the
value
represents
a
named
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
blank
node
</a>.
</li>
<li>
If
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
contains
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
mapping
for
<em>
prefix
</em>
using
a
case-sensitive
comparison,
and
<em>
suffix
</em>
does
not
does
not
begin
with
'//'
(i.e.,
it
does
not
match
a
<em>
hier-part
</em>
including
<em>
authority
</em>
(as
defined
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC3986">
RFC3986
</a>
</cite>
]),
generate
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
by
prepending
the
mapped
prefix
to
the
(possibly
empty)
suffix
using
textual
concatenation.
Note
that
an
empty
suffix
and
no
suffix
(meaning
the
value
contains
no
':'
string
at
all)
are
treated
equivalently.
</li>
<li>
Otherwise,
use
the
value
directly
as
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>.
</li>
</ol>
<p>
</p>
<div class="note">
<div class="note-title">
<span>
<ins class="diff-chg">Note
</ins></span></div><p class="">
Previous
versions
of
this
specification
used
<code>
@base
</code>
and
<code>
@vocab
</code>
to
define
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
prefixes
used
to
resolve
<a class="tref internalDFN" title="relative_iri" href="#dfn-relative_iri">
relative
IRIs
</a>.
It
was
determined
that
this
added
too
much
complexity,
but
the
issue
can
be
re-examined
in
the
future
based
on
community
input.
</p>
</div>
</div>
<div id="iri-compaction" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.5
</del>
<ins class="diff-chg">4.4
</ins>
</span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</h3>
<p>
Some
keys
and
values
are
expressed
using
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
s.
This
section
defines
an
algorithm
for
transforming
an
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
(
<em>
iri
</em>
)
to
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
or
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
using
the
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
specified
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
using
an
optional
<em>
value
</em>.
</p>
<div id="iri-compaction-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.5.1
</del>
<ins class="diff-chg">4.4.1
</ins>
</span>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
Algorithm
</h4>
<p>
The
algorithm
for
generating
a
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
is:
</p>
<ol class="algorithm">
<li>
Create
an
empty
list
of
terms
<em>
terms
</em>
that
will
be
populated
with
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
s
that
are
ranked
according
to
how
closely
they
match
<em>
value
</em>.
Initialize
<em>
highest
rank
</em>
to
<code>
0
</code>,
and
set
a
flag
<em>
list
container
</em>
to
<code>
false
</code>.
</li>
<li>
For
each
<em>
term
</em>
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>:
<ol class="algorithm">
<li>
If
the
<em>
term
</em>
's
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
is
not
a
complete
match
against
<em>
iri
</em>,
continue
to
the
next
<em>
term
</em>.
</li>
<li>
If
<em>
value
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
containing
only
the
property
<code>
@list
</code>:
<ol class="algorithm">
<li>
If
<em>
term
</em>
has
a
<code>
@container
</code>
set
to
<code>
@set
</code>,
continue
to
the
next
<em>
term
</em>.
</li>
<li>
If
<em>
list
container
</em>
is
<code>
true
</code>
and
<em>
term
</em>
does
not
have
a
<code>
container
</code>
set
to
<code>
@list
</code>,
continue
to
the
next
<em>
term
</em>.
</li>
</ol>
</li>
<li>
Otherwise,
if
<em>
term
</em>
has
a
<code>
container
</code>
set
to
<code>
@list
</code>,
continue
to
the
next
<em>
term
</em>.
</li>
<li>
Set
<em>
rank
</em>
to
the
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
of
<em>
value
</em>
by
passing
passing
<em>
term
</em>,
<em>
value
</em>,
and
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
to
the
<a href="#term-rank-algorithm">
Term
Rank
Algorithm
</a>.
</li>
<li>
If
<em>
rank
</em>
is
greater
than
<code>
0
</code>:
<ol class="algorithm">
<li>
If
<em>
term
</em>
has
a
<code>
container
</code>
set
to
<code>
@set
</code>,
then
add
<code>
1
</code>
to
<em>
rank
</em>.
</li>
<li>
If
<em>
value
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
containing
only
the
property
<code>
@list
</code>
and
<em>
list
container
</em>
is
<code>
false
</code>
and
<em>
term
</em>
has
a
<code>
container
</code>
set
to
<code>
@list
</code>,
then
set
<em>
list
container
</em>
to
<code>
true
</code>,
clear
<em>
terms
</em>,
set
<em>
highest
rank
</em>
to
<em>
rank
</em>,
and
add
<em>
term
</em>
to
<em>
terms
</em>.
</li>
<li>
Otherwise,
if
<em>
rank
</em>
is
greater
than
or
equal
to
<em>
highest
rank
</em>:
<ol class="algorithm">
<li>
If
<em>
rank
</em>
is
greater
than
<em>
highest
rank
</em>,
clear
<em>
terms
</em>
and
set
<em>
highest
rank
</em>
to
<em>
rank
</em>.
</li>
<li>
Add
<em>
term
</em>
to
<em>
terms
</em>.
</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
<li>
If
<em>
terms
</em>
is
empty,
add
a
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
representation
of
<em>
iri
</em>
for
each
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
which
maps
to
an
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
which
is
a
prefix
for
<em>
iri
</em>
where
the
resulting
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
is
not
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
The
resulting
<a class="tref internalDFN" title="compact_iri" href="#dfn-compact_iri">
compact
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
is
the
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
associated
with
the
partially
matched
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
concatenated
with
a
colon
(:)
character
and
the
unmatched
part
of
<em>
iri
</em>.
</li>
<li>
If
<em>
terms
</em>
is
empty,
return
<em>
iri
</em>.
</li>
<li>
Otherwise,
return
the
shortest
and
lexicographically
least
value
in
<em>
terms
</em>.
</li>
</ol>
<p>
</p>
</div>
<div id="term-rank-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.5.2
</del>
<ins class="diff-chg">4.4.2
</ins>
</span>
Term
Rank
Algorithm
</h4>
<p>
When
selecting
among
multiple
possible
terms
for
a
given
property,
it
may
be
that
multiple
<a class="tref internalDFN" title="term" href="#dfn-term">
terms
</a>
are
defined
with
the
same
<a class="tref internalDFN" title="iri" href="#dfn-iri">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>,
but
differ
in
<code>
@type
</code>,
<code>
@container
</code>
or
<code>
@language
</code>.
The
purpose
of
this
algorithm
is
to
take
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
and
a
value
and
give
it
a
<dfn title="term_rank" id="dfn-term_rank">
term
rank
</dfn>.
The
selection
can
then
be
based,
partly,
on
the
term
having
the
highest
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>.
</p>
<p>
Given
a
<a class="tref internalDFN" title="term" href="#dfn-term">
term
</a>
<em>
term
</em>,
<em>
value
</em>,
and
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
determine
the
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
using
the
following
steps:
</p>
<ol class="algorithm">
<li>
If
<em>
value
</em>
is
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
3
</code>.
</li>
<li>
Otherwise,
if
<em>
value
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
containing
only
the
property
<code>
@list
</code>:
<ol class="algorithm">
<li>
If
the
<code>
@list
</code>
property
is
an
empty
array,
if
<em>
term
</em>
has
<code>
@container
</code>
set
to
<code>
@list
</code>,
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
1
</code>,
otherwise
<code>
0
</code>.
</li>
<li>
Otherwise,
return
the
sum
of
the
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
s
for
every
entry
in
the
list.
</li>
</ol>
</li>
<li>
Otherwise,
<em>
value
</em>
<em class="rfc2119" title="must">
must
</em>
be
a
<a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition">
subject
definition
</a>,
<a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">
subject
reference
</a>,
or
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
having
a
<code>
@value
</code>.
<ol class="algorithm">
<li>
If
<em>
value
</em>
has
a
<code>
@value
</code>
property:
<ol class="algorithm">
<li>
If
<em>
value
</em>
has
a
<code>
@type
</code>
property
matching
a
<code>
@type
</code>
coercion
for
<em>
term
</em>,
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
3
</code>,
otherwise
if
<em>
term
</em>
has
no
<code>
@type
</code>
coercion
and
no
<code>
@language
</code>,
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
1
</code>,
otherwise
<code>
0
</code>.
</li>
<li>
Otherwise,
if
<code>
@value
</code>
is
not
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
if
<em>
term
</em>
has
no
<code>
@type
</code>
or
<code>
@language
</code>
it
is
<code>
2
</code>,
otherwise
<code>
1
</code>.
</li>
<li>
Otherwise,
if
<em>
value
</em>
has
no
<code>
@language
</code>
property,
if
<em>
term
</em>
has
<code>
@language
</code>
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
or
<em>
term
</em>
has
no
<code>
@type
</code>
or
<code>
@language
</code>
and
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
has
no
<code>
@language
</code>,
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
3
</code>,
otherwise
<code>
0
</code>.
</li>
<li>
Otherwise,
if
<em>
value
</em>
has
a
<code>
@language
</code>
property
matching
a
<code>
@language
</code>
definition
for
<em>
term
</em>
(or
<em>
term
</em>
has
no
<code>
@type
</code>
or
<code>
@language
</code>
definition
and
<code>
@language
</code>
in
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
matches
the
<em>
value
</em>
<code>
@language
</code>
),
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
3
</code>,
otherwise
if
<em>
term
</em>
has
no
<code>
@type
</code>
coercion
and
no
<code>
@language
</code>,
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
1
</code>,
otherwise
<code>
0
</code>.
</li>
</ol>
</li>
<li>
Otherwise,
if
<em>
term
</em>
has
<code>
@type
</code>
coerced
to
<code>
@id
</code>,
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
3
</code>,
otherwise
if
<em>
term
</em>
has
no
<code>
@type
</code>
coercion
and
no
<code>
@language
</code>,
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>
is
<code>
1
</code>,
otherwise
<code>
0
</code>.
</li>
</ol>
</li>
<li>
Return
<a class="tref internalDFN" title="term_rank" href="#dfn-term_rank">
term
rank
</a>.
</li>
</ol>
</div>
</div>
<div id="value-expansion" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.6
</del>
<ins class="diff-chg">4.5
</ins>
</span>
Value
Expansion
</h3>
<p>
Some
values
in
JSON-LD
can
be
expressed
in
a
compact
form.
These
values
are
required
to
be
expanded
at
times
when
processing
JSON-LD
documents.
</p>
<p>
The
algorithm
for
expanding
a
<em>
value
</em>
takes
an
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
It
is
implemented
as
follows:
</p>
<ol class="algorithm">
<li>
If
<em>
value
</em>
is
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
the
<em>
value
</em>
is
already
expanded.
</li>
<li>
If
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
<code>
@graph
</code>
or
the
target
of
an
<code>
@id
</code>
coercion,
expand
the
value
into
an
object
with
a
key-value
pair
where
the
key
is
<code>
@id
</code>
and
the
value
is
the
expanded
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
according
to
the
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
rules.
</li>
<li>
Otherwise,
if
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
not
a
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>,
then
expand
<em>
value
</em>
into
an
object:
<ol class="algorithm">
<li>
Set
the
first
key-value
pair
to
<code>
@value
</code>
and
the
unexpanded
<em>
value
</em>.
</li>
<li>
If
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
the
target
of
typed
literal
coercion,
set
the
second
key-value
pair
to
<code>
@type
</code>
and
the
associated
coercion
datatype
expanded
according
to
the
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
rules.
</li>
<li>
Otherwise,
if
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
the
target
of
language
tagging,
set
the
second
key-value
pair
to
<code>
@language
</code>
and
value
of
the
language
tagging
from
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</li>
</ol>
</li>
<li>
Otherwise,
<em>
value
</em>
is
already
expanded.
</li>
</ol>
</div>
<div id="value-compaction" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.7
</del>
<ins class="diff-chg">4.6
</ins>
</span>
Value
Compaction
</h3>
<p>
Some
values,
such
as
<a class="tref internalDFN" title="iri" href="#dfn-iri">
IRIs
</a>
and
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literals
</a>,
may
be
expressed
in
an
expanded
form
in
JSON-LD.
These
values
are
required
to
be
compacted
at
times
when
processing
JSON-LD
documents.
</p>
<p>
The
algorithm
for
compacting
an
expanded
value
<em>
value
</em>
takes
an
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
It
is
implemented
as
follows:
</p>
<ol class="algorithm">
<li>
If
<em>
value
</em>
only
has
one
<del class="diff-old">property,
</del>
<ins class="diff-chg">property
and
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
has
no
default
language,
</ins>
then
the
compacted
value
is
the
value
of
<code>
@value
</code>.
</li>
<li>
Otherwise,
if
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
<code>
@graph
</code>,
the
compacted
value
is
the
value
associated
with
the
<code>
@id
</code>
key,
processed
according
to
the
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
steps.
</li>
<li>
Otherwise,
if
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
contains
a
coercion
target
for
the
key
that
matches
the
expression
of
the
value,
compact
the
value
using
the
following
steps:
<ol class="algorithm">
<li>
If
the
coercion
target
is
an
<code>
@id
</code>,
the
compacted
value
is
the
value
associated
with
the
<code>
@id
</code>
key,
processed
according
to
the
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
steps.
</li>
<li>
If
the
coercion
target
is
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>,
the
compacted
value
is
the
value
associated
with
the
<code>
@value
</code>
key.
</li>
</ol>
</li>
<li>
Otherwise,
if
<em>
value
</em>
contains
an
<code>
@id
</code>
key,
the
compacted
value
is
<em>
value
</em>
with
the
value
of
<code>
@id
</code>
processed
according
to
the
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
steps.
</li>
<li>
Otherwise,
if
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
contains
a
<code>
@language
</code>,
which
matches
the
<code>
@language
</code>
of
the
value,
or
the
value
has
only
a
<code>
@value
</code>
key,
the
compacted
value
is
the
value
associated
with
the
<code>
@value
</code>
key.
</li>
<li>
Otherwise,
if
the
value
contains
a
<code>
@type
</code>
key,
the
compacted
value
is
<em>
value
</em>
with
the
<code>
@type
</code>
value
processed
according
to
the
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
steps.
</li>
<li>
Otherwise,
the
value
is
not
modified.
</li>
</ol>
</div>
<del class="diff-old">3.8
Generate
Blank
Node
Identifier
This
algorithm
is
used
by
the
Framing
Algorithm
and
Convert
From
RDF
Algorithm
to
deterministicly
name
blank
node
identifiers.
It
uses
a
identifier
map
and
prefix
and
takes
a
possibly
null
identifier
and
returns
a
new
identifier
based
on
prefix
.
The
variable
next
identifier
is
initialized
to
prefix
appended
with
0
.
If
the
old
identifier
is
not
null
and
is
in
identifier
map
return
the
mapped
identifier.
Otherwise,
if
old
identifier
is
not
null,
create
a
new
entry
in
identifier
map
initialized
to
the
current
value
of
next
identifier
.
Increment
next
identifier
by
adding
one
to
the
integer
suffix.
Return
the
mapped
identifier.
Otherwise,
increment
next
identifier
by
adding
one
to
the
integer
suffix
and
return
its
original
value.
</del>
<div id="expansion-1" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.9
</del>
<ins class="diff-chg">4.7
</ins>
</span>
Expansion
</h3>
<p>
Expansion
is
the
process
of
taking
a
JSON-LD
document
and
applying
a
context
such
that
all
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>,
datatypes,
and
literal
values
are
expanded
so
that
the
context
is
no
longer
necessary.
JSON-LD
document
expansion
is
typically
used
as
a
part
of
<del class="diff-old">Framing
.
</del>
<ins class="diff-chg">other
JSON-LD
API
methods.
</ins>
</p>
<p>
For
example,
assume
the
following
JSON-LD
input
document:
</p>
<del class="diff-old">{
</del>
<div class="example"><div class="example-title"><span>Example 13</span></div><pre class="example">{
   &quot;@context&quot;:
   {
      &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
      &quot;homepage&quot;: {
        &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
        &quot;@type&quot;, &quot;@id&quot;
      }
   },
   &quot;name&quot;: &quot;Manu Sporny&quot;,
   &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}
</pre>
</div>
<p>
Running
the
JSON-LD
Expansion
algorithm
against
the
JSON-LD
input
document
provided
above
would
result
in
the
following
output:
</p>
<del class="diff-old">{
</del>
<div class="example"><div class="example-title"><span>Example 14</span></div><pre class="example">{
   &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
   &quot;http://xmlns.com/foaf/0.1/homepage&quot;: {
      &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
   }
}
</pre>
</div>
<div id="expansion-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.9.1
</del>
<ins class="diff-chg">4.7.1
</ins>
</span>
Expansion
Algorithm
</h4>
<p>
The
algorithm
takes
three
input
variables:
an
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
an
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>,
and
an
<em>
element
</em>
to
be
expanded.
To
begin,
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
is
set
to
the
result
of
performing,
<a href="#context-processing">
Context
Processing
</a>
on
the
passed
<em>
context
</em>,
or
to
the
<a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">
initial
context
</a>
if
<em>
context
</em>
is
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
set
to
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
and
<em>
element
</em>
is
set
to
the
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>.
</p>
<ol class="algorithm">
<li>
If
<em>
element
</em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
process
each
entry
in
<em>
element
</em>
recursively
using
this
algorithm,
passing
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
If
has
a
<code>
@container
</code>
set
to
<code>
@list
</code>
and
any
entry
in
<em>
element
</em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
or
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
containing
a
<code>
@list
</code>
property,
throw
an
exception,
as
lists
of
lists
are
not
allowed.
If
the
expanded
entry
is
null,
drop
it.
If
it's
an
array,
merge
its
entries
with
<em>
element
</em>
's
entries.
</li>
<li>
Otherwise,
if
<em>
element
</em>
is
an
object
<ol class="algorithm">
<li>
If
<em>
element
</em>
has
a
<code>
@context
</code>
property,
update
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
according
to
the
steps
outlined
in
<a href="#context-processing">
Context
Processing
</a>
and
remove
the
<code>
@context
</code>
property.
</li>
<li>
Then,
proceed
and
process
each
<em>
property
</em>
and
<em>
value
</em>
in
<em>
element
</em>
as
follows:
<ol class="algorithm">
<li>
Remove
<em>
property
</em>
from
<em>
element
</em>,
expand
<em>
property
</em>
according
to
the
steps
outlined
in
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>.
Set
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
the
original
un-expanded
<em>
property
</em>
if
<em>
property
</em>
is
not
a
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>.
</li>
<li>
If
<em>
property
</em>
does
not
expand
to
a
keyword
or
an
<a class="tref internalDFN" title="absolute_iri" href="#dfn-absolute_iri">
absolute
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</a>
(i.e.,
it
doesn't
contain
a
colon),
continue
with
the
next
property
from
<em>
element
</em>.
</li>
<li>
If
<em>
value
</em>
is
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>
and
<em>
property
</em>
is
not
<code>
@value
</code>,
continue
with
the
next
property
from
<em>
element
</em>.
</li>
<li>
If
the
<em>
property
</em>
is
<code>
@id
</code>
the
<em>
value
</em>
<em class="rfc2119" title="must">
must
</em>
be
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>.
Expand
the
<em>
value
</em>
according
to
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>.
</li>
<li>
Otherwise,
if
the
<em>
property
</em>
is
<code>
@type
</code>:
<ol class="algorithm">
<li>
If
<em>
value
</em>
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
expand
according
to
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>.
</li>
<li>
Otherwise,
if
<em>
value
</em>
is
a
<a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">
subject
reference
</a>,
the
expanded
value
is
the
result
of
performing
<a href="#iri-expansion">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Expansion
</a>
on
the
value
of
<code>
@id
</code>.
</li>
<li>
Otherwise,
if
<em>
value
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
Object
</a>,
it
must
be
empty
(used
for
<cite>
<a href="../json-ld-framing/#framing">
Framing
</a>
</cite>
).
</li>
<li>
Otherwise,
if
<em>
value
</em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
all
elements
must
be
either
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>
or
<a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">
subject
reference
</a>.
Expand
<em>
value
</em>
for
each
of
its
entries
using
the
previous
three
steps.
</li>
</ol>
</li>
<li>
Otherwise,
if
the
<em>
property
</em>
is
<code>
@value
</code>
or
<code>
@language
</code>
the
<em>
value
</em>
<em class="rfc2119" title="must not">
must
not
</em>
be
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
or
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
</li>
<li>
Otherwise,
if
the
<em>
property
</em>
is
<code>
@list
</code>
or
<code>
@set
</code>
expand
<em>
value
</em>
recursively
using
this
algorithm,
passing
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
and
<em>
active
property
</em>.
If
the
expanded
<em>
value
</em>
is
not
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
convert
it
to
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
If
<em>
property
</em>
is
<code>
@list
</code>
and
any
entry
in
<em>
value
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
containing
an
<code>
@list
</code>
property,
throw
an
exception,
as
lists
of
lists
are
not
supported.
</li>
<li>
Otherwise,
expand
<em>
value
</em>
recursively
using
this
algorithm,
passing
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
</li>
<li>
If
<em>
property
</em>
is
not
a
keyword
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
has
a
<code>
@container
</code>
<code>
@list
</code>
and
the
expanded
<em>
value
</em>
is
not
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
convert
<em>
value
</em>
to
an
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
with
an
<code>
@list
</code>
property
whose
value
is
set
to
<em>
value
</em>
(unless
<em>
value
</em>
is
already
in
that
form).
</li>
<li>
Convert
<em>
value
</em>
to
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
form
unless
<em>
value
</em>
is
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>
or
<em>
property
</em>
is
<code>
@id
</code>,
<code>
@type
</code>,
<code>
@value
</code>,
or
<code>
@language
</code>.
</li>
<li>
If
<em>
value
</em>
is
not
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
either
merge
<em>
value
</em>
into
an
existing
<em>
property
</em>
property
of
<em>
element
</em>
or
create
a
new
<em>
property
</em>
property
with
<em>
value
</em>
as
value.
</li>
</ol>
</li>
<li>
If
the
processed
<em>
element
</em>
has
an
<code>
@value
</code>
property
<ol class="algorithm">
<li>
<em>
element
</em>
<em class="rfc2119" title="must not">
must
not
</em>
have
more
than
one
other
property,
which
can
either
be
<code>
@language
</code>
or
<code>
@type
</code>
with
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>
value.
</li>
<li>
if
the
value
of
<code>
@value
</code>
equals
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
replace
<em>
element
</em>
with
the
value
of
<code>
@value
</code>.
</li>
</ol>
</li>
<li>
Otherwise,
if
<em>
element
</em>
has
an
<code>
@type
</code>
property
and
its
value
is
not
in
the
form
of
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
convert
it
to
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
</li>
<li>
If
<em>
element
</em>
has
an
<code>
@set
</code>
or
<code>
@list
</code>
property,
it
<em class="rfc2119" title="must">
must
</em>
be
the
only
property.
Set
<em>
element
</em>
to
the
value
of
<code>
@set
</code>
;
leave
<code>
@list
</code>
untouched.
</li>
<li>
If
<em>
element
</em>
has
just
a
<code>
@language
</code>
property,
set
<em>
element
</em>
to
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>.
</li>
</ol>
</li>
<li>
Otherwise,
expand
<em>
element
</em>
according
to
the
<a href="#value-expansion">
Value
Expansion
</a>
rules,
passing
copies
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
</li>
</ol>
<p>
If,
after
the
algorithm
outlined
above
is
run,
the
resulting
<em>
element
</em>
is
an
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
with
just
a
<code>
@graph
</code>
property,
<em>
element
</em>
is
set
to
the
value
of
<code>
@graph
</code>
's
value.
Finally,
if
<em>
element
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>,
it
is
wrapped
into
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
</p>
</div>
</div>
<div id="compaction-1" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.10
</del>
<ins class="diff-chg">4.8
</ins>
</span>
Compaction
</h3>
<p>
Compaction
is
the
process
of
taking
a
JSON-LD
document
and
applying
a
context
such
that
the
most
compact
form
of
the
document
is
generated.
JSON
is
typically
expressed
in
a
very
compact,
key-value
format.
That
is,
full
IRIs
are
rarely
used
as
keys.
At
times,
a
JSON-LD
document
may
be
received
that
is
not
in
its
most
compact
form.
JSON-LD,
via
the
API,
provides
a
way
to
compact
a
JSON-LD
document.
</p>
<p>
For
example,
assume
the
following
JSON-LD
input
document:
</p>
<del class="diff-old">{
</del>
<div class="example"><div class="example-title"><span>Example 15</span></div><pre class="example">{
  &quot;http://xmlns.com/foaf/0.1/name&quot;: &quot;Manu Sporny&quot;,
  &quot;http://xmlns.com/foaf/0.1/homepage&quot;: {
    &quot;@id&quot;: &quot;http://manu.sporny.org/&quot;
  }
}
</pre>
</div>
<p>
Additionally,
assume
the
following
developer-supplied
JSON-LD
context:
</p>
<del class="diff-old">{
</del>
<div class="example"><div class="example-title"><span>Example 16</span></div><pre class="example">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;homepage&quot;: {
      &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@type&quot;: &quot;@id&quot;
    }
  }
}
</pre>
</div>
<p>
Running
the
JSON-LD
Compaction
algorithm
given
the
context
supplied
above
against
the
JSON-LD
input
document
provided
above
would
result
in
the
following
output:
</p>
<del class="diff-old">{
</del>
<div class="example"><div class="example-title"><span>Example 17</span></div><pre class="example">{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;homepage&quot;: {
      &quot;@id&quot;: &quot;http://xmlns.com/foaf/0.1/homepage&quot;,
      &quot;@type&quot;: &quot;@id&quot;
    }
  },
  &quot;name&quot;: &quot;Manu Sporny&quot;,
  &quot;homepage&quot;: &quot;http://manu.sporny.org/&quot;
}
</pre>
</div>
<p>
The
compaction
algorithm
also
enables
the
developer
to
map
any
expanded
format
into
an
application-specific
compacted
format.
While
the
context
provided
above
mapped
<code>
http://xmlns.com/foaf/0.1/name
</code>
to
<strong>
name
</strong>,
it
could
have
also
mapped
it
to
any
arbitrary
string
provided
by
the
developer.
</p>
<div id="compaction-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.10.1
</del>
<ins class="diff-chg">4.8.1
</ins>
</span>
Compaction
Algorithm
</h4>
<p>
The
algorithm
takes
three
input
variables:
an
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>,
an
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>,
and
an
<em>
element
</em>
to
be
compacted.
To
begin,
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
is
set
to
the
result
of
performing
<a href="#context-processing">
Context
Processing
</a>
on
the
passed
<em>
context
</em>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
is
set
to
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
and
<em>
element
</em>
is
set
to
the
result
of
performing
the
<a href="#expansion-algorithm">
Expansion
Algorithm
</a>
on
the
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>.
This
removes
any
existing
context
to
allow
the
given
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
to
be
cleanly
applied.
</p>
<ol class="algorithm">
<li>
If
<em>
element
</em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
process
each
entry
in
<em>
element
</em>
recursively
using
this
algorithm,
passing
a
copy
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
and
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
If
<em>
element
</em>
has
a
single
item,
the
compacted
value
is
that
item;
otherwise
the
compacted
value
is
<em>
element
</em>.
</li>
<li>
Otherwise,
if
<em>
element
</em>
is
an
object:
<ol class="algorithm">
<li>
If
<em>
element
</em>
has
an
<code>
@value
</code>
property
or
element
is
a
<a class="tref internalDFN" title="subject_reference" href="#dfn-subject_reference">
subject
reference
</a>,
return
the
result
of
performing
<a href="#value-compaction">
Value
Compaction
</a>
on
<em>
element
</em>
using
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
</li>
<li>
Otherwise,
if
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
has
a
<code>
@container
</code>
mapping
to
<code>
@list
</code>
and
<em>
element
</em>
has
a
corresponding
<code>
@list
</code>
property,
recursively
compact
that
property's
value
passing
a
copy
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
and
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
ensuring
that
the
result
is
an
array
and
removing
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>
values.
Return
either
the
result
as
an
array,
as
an
object
with
a
key
of
<code>
@list
</code>
(or
appropriate
alias
from
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
).
</li>
<li>
Otherwise,
construct
<em>
output
</em>
as
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
used
for
returning
the
result
of
compacting
<em>
element
</em>.
For
each
<em>
property
</em>
and
<em>
value
</em>
in
<em>
element:
</em>
<ol class="algorithm">
<li>
If
<em>
property
</em>
is
<code>
@id
</code>
or
<code>
@type
</code>
<ol class="algorithm">
<li>
Set
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
the
result
of
performing
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
on
<em>
property
</em>.
</li>
<li>
If
<em>
value
</em>
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
the
compacted
<em>
value
</em>
is
the
result
of
performing
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
on
<em>
value
</em>.
</li>
<li>
Otherwise,
<em>
value
</em>
<em class="rfc2119" title="must">
must
</em>
be
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
Perform
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
on
every
entry
of
<em>
value
</em>.
If
<em>
value
</em>
contains
just
one
entry,
<em>
value
</em>
is
set
to
that
entry.
</li>
<li>
Add
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
the
expanded
<em>
value
</em>
to
<em>
output
</em>.
</li>
</ol>
</li>
<li>
Otherwise,
<em>
value
</em>
<em class="rfc2119" title="must">
must
</em>
be
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
</li>
<li>
If
<em>
value
</em>
is
empty:
<ol class="algorithm">
<li>
Set
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
the
result
of
performing
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
on
<em>
property
</em>.
</li>
<li>
Create
an
entry
in
<em>
output
</em>
for
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
<em>
value
</em>.
</li>
</ol>
</li>
<li>
For
each
<em>
item
</em>
in
<em>
value
</em>:
<ol class="algorithm">
<li>
Set
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
the
result
of
performing
<a href="#iri-compaction">
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
Compaction
</a>
for
<em>
property
</em>
and
<em>
item
</em>
using
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>.
</li>
<li>
Compact
<em>
item
</em>
by
recursively
performing
this
algorithm
passing
a
copy
of
the
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">
active
context
</a>
and
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
</li>
<li>
If
an
entry
already
exists
in
<em>
output
</em>
for
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>,
convert
it
to
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
if
necessary,
and
append
the
compacted
<em>
value
</em>.
</li>
<li>
Otherwise,
if
the
compacted
<em>
value
</em>
is
not
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
has
a
<code>
@container
</code>
mapping
to
<code>
@set
</code>,
create
an
entry
in
<em>
output
</em>
for
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
<em>
value
</em>
as
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
</li>
<li>
Otherwise,
create
an
entry
in
<em>
output
</em>
for
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
<em>
value
</em>.
</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
<li>
Otherwise,
return
<em>
element
</em>
as
the
compacted
<em>
element
</em>.
<div class="issue">
<div class="issue-title">
<span>
<ins class="diff-new">Issue
7
</ins></span></div><div class="">
Perhaps
this
should
also
call
<a href="#value-compaction">
Value
Compaction
</a>
on
native
types
and
strings,
which
could
<del class="diff-old">consolodate
</del>
<ins class="diff-chg">consolidate
</ins>
potential
transformation
in
one
place.
</div>
</div>
</li>
</ol>
<p>
If,
after
the
algorithm
outlined
above
is
run,
the
resulting
<em>
element
</em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
put
<em>
element
</em>
into
the
<code>
@graph
</code>
property
of
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
and
then
set
<em>
element
</em>
to
that
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>.
Finally,
add
a
<code>
@context
</code>
property
to
<em>
element
</em>
and
set
it
to
the
initially
passed
<em>
context
</em>.
</p>
</div>
</div>
<del class="diff-old">3.11
Framing
JSON-LD
Framing
allows
developers
to
query
by
example
and
force
a
specific
tree
layout
to
a
JSON-LD
document.
A
JSON-LD
document
is
a
representation
of
a
directed
graph.
A
single
directed
graph
can
have
many
different
serializations,
each
expressing
exactly
the
same
information.
Developers
typically
work
with
trees,
represented
as
JSON
object
s.
While
mapping
a
graph
to
a
tree
can
be
done,
the
layout
of
the
end
result
must
be
specified
in
advance.
A
Frame
can
be
used
by
a
developer
on
a
JSON-LD
document
to
specify
a
deterministic
layout
for
a
graph.
Framing
is
the
process
of
taking
a
JSON-LD
document,
which
expresses
a
graph
of
information,
and
applying
a
specific
graph
layout
(called
a
Frame
).
Framing
makes
use
of
the
Subject
Map
Generation
algorithm
to
place
each
object
defined
in
the
JSON-LD
document
into
a
flat
list
of
objects,
allowing
them
to
be
operated
upon
by
the
framing
algorithm.
3.11.1
Framing
Algorithm
Terms
input
frame
the
initial
frame
provided
to
the
framing
algorithm.
framing
context
a
context
containing
a
map
of
embeds
,
the
object
embed
flag
,
the
explicit
inclusion
flag
and
the
omit
default
flag
.
map
of
embeds
a
map
that
tracks
if
a
subject
is
to
be
embedded
in
the
output
of
the
Framing
Algorithm
;
it
maps
a
subject
@id
to
a
parent
JSON
object
and
property
or
parent
array.
object
embed
flag
a
flag
specifying
that
objects
should
be
directly
embedded
in
the
output,
instead
of
being
referred
to
by
their
IRI
.
explicit
inclusion
flag
a
flag
specifying
that
for
properties
to
be
included
in
the
output,
they
must
be
explicitly
declared
in
the
framing
context
.
omit
default
flag
a
flag
specifying
that
properties
that
are
missing
from
the
JSON-LD
input
,
but
present
in
the
input
frame
should
be
omitted
from
the
output.
map
of
flattened
subjects
a
map
of
subjects
that
is
the
result
of
the
Subject
Map
Generation
algorithm
.
3.11.2
Framing
Algorithm
This
algorithm
is
a
work
in
progress.
Presently,
it
only
works
for
documents
without
named
graphs.
The
framing
algorithm
takes
an
JSON-LD
input
(
expanded
input
)
and
an
input
frame
(
expanded
frame
)
that
have
been
expanded
according
to
the
Expansion
Algorithm
,
and
a
number
of
options
and
produces
JSON-LD
output
.
Create
framing
context
using
null
for
the
map
of
embeds
,
the
object
embed
flag
set
to
true
,
the
explicit
inclusion
flag
set
to
false
,
and
the
omit
default
flag
set
to
false
along
with
map
of
flattened
subjects
set
to
the
@merged
property
of
the
result
of
performing
the
Subject
Map
Generation
algorithm
on
expanded
input
.
Also
create
results
as
an
empty
array
.
Invoke
the
recursive
algorithm
using
framing
context
(
state
),
the
map
of
flattened
subjects
(
subjects
),
expanded
frame
(
frame
),
result
as
parent
,
and
null
as
active
property
.
The
following
series
of
steps
is
the
recursive
portion
of
the
framing
algorithm:
Validate
frame
.
Create
a
set
of
matched
subjects
by
filtering
subjects
checking
the
map
of
flattened
subjects
against
frame
:
If
frame
has
a
@type
property
containing
one
or
more
IRIs
match
any
subject
definition
with
a
@type
property
including
any
of
those
IRIs
.
Otherwise,
if
frame
has
a
@type
property
only
a
empty
JSON
object
,
matches
any
subject
definition
with
a
@type
property,
regardless
of
the
actual
values.
Otherwise,
match
if
the
subject
definition
contains
all
of
the
non-
keyword
properties
in
frame
.
Get
values
for
embedOn
and
explicitOn
by
looking
in
frame
for
the
keys
@embed
and
@explicit
using
the
current
values
for
object
embed
flag
and
explicit
inclusion
flag
from
state
if
not
found.
For
each
id
and
subject
from
the
set
of
matched
subjects,
ordered
by
id
:
If
the
active
property
is
null
,
set
the
map
of
embeds
in
state
to
an
empty
map.
Initialize
output
with
@id
and
id
.
Initialize
embed
with
parent
and
active
property
to
property
.
If
embedOn
is
true
,
and
id
is
in
map
of
embeds
from
state
:
Set
existing
to
the
value
of
id
in
map
of
embeds
and
set
embedOn
to
false
.
If
existing
has
a
parent
which
is
an
array
containing
a
JSON
object
with
@id
equal
to
id
,
element
has
already
been
embedded
and
can
be
overwritten,
so
set
embedOn
to
true
.
Otherwise,
existing
has
a
parent
which
is
a
subject
definition
.
Set
embedOn
to
true
if
any
of
the
items
in
parent
property
is
a
subject
definition
or
subject
reference
for
id
because
the
embed
can
be
overwritten.
If
embedOn
is
true
,
existing
is
already
embedded
but
can
be
overwritten,
so
Remove
Embedded
Definition
for
id
.
If
embedOn
is
false
,
add
output
to
parent
by
either
appending
to
parent
if
it
is
an
array
,
or
appending
to
active
property
in
parent
otherwise.
Otherwise:
Add
embed
to
map
of
embeds
for
id
.
Process
each
property
and
value
in
the
matched
subject
,
ordered
by
property
:
If
property
is
a
keyword
,
add
property
and
a
copy
of
value
to
output
and
continue
with
the
next
property
from
subject
.
If
property
is
not
in
frame
:
If
explicitOn
is
false
,
Embed
values
from
subject
in
output
using
subject
as
element
and
property
as
active
property
.
Continue
to
next
property.
Process
each
item
from
value
as
follows:
If
item
is
a
JSON
object
with
the
key
@list
,
then
create
a
JSON
object
named
list
with
the
key
@list
and
the
value
of
an
empty
array.
Append
list
to
property
in
output
.
Process
each
listitem
in
the
@list
array
as
follows:
If
listitem
is
a
subject
reference
process
listitem
recursively
using
this
algorithm
passing
a
new
map
of
subjects
that
contains
the
@id
of
listitem
as
the
key
and
the
subject
definition
from
the
original
map
of
flattened
subjects
as
the
value.
Pass
the
first
value
from
frame
for
property
as
frame
,
list
as
parent
,
and
@list
as
active
property
.
Otherwise,
append
a
copy
of
listitem
to
@list
in
list
.
If
item
is
a
subject
reference
process
item
recursively
using
this
algorithm
passing
a
new
map
as
subjects
that
contains
the
@id
of
item
as
the
key
and
the
subject
definition
from
the
original
map
of
flattened
subjects
as
the
value.
Pass
the
first
value
from
frame
for
property
as
frame
,
output
as
parent
,
and
property
as
active
property
.
Passing
a
subject
reference
doesn't
work
if
this
map
is
used
recursively.
Presently
pass
subject
definition
from
original
map
of
flattened
subjects
.
Otherwise,
append
a
copy
of
item
to
active
property
in
output
.
Process
each
property
and
value
in
frame
,
where
property
is
not
a
keyword
,
ordered
by
property
:
Set
property
frame
to
the
first
item
in
value
or
a
newly
created
JSON
object
if
value
is
empty.
Skip
to
the
next
property
in
frame
if
property
is
in
output
or
if
property
frame
contains
@omitDefault
which
is
true
or
if
it
does
not
contain
@omitDefault
but
the
value
of
omit
default
flag
true
.
Set
the
value
of
property
in
output
to
a
new
JSON
object
with
a
property
@preserve
and
a
value
that
is
a
copy
of
the
value
of
@default
in
frame
if
it
exists,
or
the
string
@null
otherwise.
Add
output
to
parent
.
If
parent
is
an
array
,
append
output
,
otherwise
append
output
to
active
property
in
parent
.
At
the
completion
of
the
recursive
algorithm,
results
will
contain
the
top-level
subject
definition
s.
The
final
two
steps
of
the
framing
algorithm
require
results
to
be
compacted
according
to
the
Compaction
Algorithm
by
using
the
context
provided
in
the
input
frame
.
If
the
frame
has
no
context,
compaction
is
performed
with
an
empty
context
(not
a
null
context).
The
compaction
result
must
use
the
@graph
keyword
at
the
top-level,
even
if
the
context
is
empty
or
if
there
is
only
one
element
to
put
in
the
@graph
array.
Subsequently,
replace
all
key-value
pairs
where
the
key
is
@preserve
with
the
value
from
the
key-pair.
If
the
value
from
the
key-pair
is
@null
,
replace
the
value
with
null
.
If,
after
replacement,
an
array
contains
only
the
value
null
remove
the
value,
leaving
an
empty
array.
The
resulting
value
is
the
final
JSON-LD
output
.
The
algorithm
needs
to
be
updated
to
consider
@graph
.
See
ISSUE-118
for
details.
3.11.3
Subject
Map
Generation
The
Subject
Map
Generation
algorithm
takes
as
input
an
expanded
JSON-LD
document
and
results
in
a
JSON
object
subjectMap
holding
a
flat
representation
of
the
graphs
and
nodes
represented
in
the
document.
All
nodes
that
are
not
uniquely
identified
by
an
IRI
get
assigned
a
(new)
blank
node
identifier.
The
resulting
subjectMap
document
will
have
a
property
for
every
graph
in
the
document
whose
value
is
another
object
with
a
property
for
every
node
represented
in
the
document.
While
the
default
graph
is
stored
under
the
@default
property
and
the
merged
graph
under
the
@merged
property,
all
other
graphs
are
stored
under
their
respective
IRIs
.
The
algorithm
takes
as
input
the
expanded
JSON-LD
document
as
element
,
the
initially
empty
subjectMap
,
@default
as
graph
,
and
null
as
list
.
If
element
is
an
array,
process
each
entry
in
element
recursively,
using
this
algorithm
and
return.
If
element
is
not
a
JSON
object
or
if
it
has
a
@value
property,
then
if
list
is
not
null
,
append
element
to
list
and
return.
If
the
@id
property
exists
and
is
an
IRI
,
set
id
to
its
value,
otherwise
set
it
to
a
blank
node
identifer
created
by
the
Generate
Blank
Node
Identifier
algorithm.
If
list
is
not
null
,
append
a
new
subject
reference
to
list
using
id
at
the
value
for
@id
.
Let
subjects
be
the
value
in
subjectMap
where
the
key
is
graph
;
if
no
such
value
exists,
insert
a
new
JSON
object
for
the
key
graph
.
If
id
is
not
in
subjects
,
create
a
new
JSON
object
subject
with
id
as
the
value
for
@id
.
Let
subject
be
the
value
of
id
in
subjects
.
For
each
property
that
is
not
@id
and
each
value
in
element
ordered
by
property
:
If
property
is
@graph
,
recursively
call
this
algorithm
passing
value
for
element
,
subjectMap
,
null
for
list
and
if
graph
is
merged
use
graph
,
otherwise
use
id
for
graph
and
then
continue.
If
property
is
not
@type
and
is
a
keyword,
merge
property
and
value
into
subject
and
then
continue.
For
each
value
v
in
the
array
value
:
If
v
is
a
subject
definition
or
subject
reference
:
If
the
property
@id
is
not
an
IRI
or
it
does
not
exist,
map
v
to
a
new
blank
node
identifier
to
avoid
collisions.
If
one
does
not
already
exist,
add
a
subject
reference
for
v
into
subject
for
property
.
Recursively
call
this
algorithm
passing
v
for
value
,
subjectMap
,
graph
,
and
null
for
list
.
Otherwise
if
v
has
the
property
@list
then
recursively
call
this
algorithm
with
the
value
of
@list
as
element
,
subjectMap
,
graph
,
and
a
new
array
flattenedList
as
list
.
Create
a
new
JSON
object
with
the
property
@list
set
to
flattenedList
and
add
it
to
subject
for
property
.
Otherwise,
if
property
is
@type
and
v
is
not
an
IRI
,
generate
a
new
blank
node
identifier
and
add
it
to
subject
for
property
.
Otherwise,
add
v
to
subject
for
property
.
After
the
above
outlined
algorithm
has
been
executed,
the
subject
map
for
all
graphs
including
the
default
graph
are
contained
in
subjectMap
.
To
also
create
the
subject
map
for
the
merged
graph,
execute
the
algorithm
again,
but
pass
merged
for
graph
.
3.11.4
Remove
Embedded
Definition
This
algorithm
replaces
an
already
embedded
subject
definition
with
a
subject
reference
.
It
then
recursively
removes
any
entries
in
the
map
of
embeds
that
had
the
removed
subject
definition
in
their
parent
chain.
About
as
clear
as
mud
The
algorithm
is
invoked
with
a
framing
context
and
subject
id
id
.
Find
embed
from
map
of
embeds
for
id
.
Let
parent
and
property
be
from
embed
.
If
parent
is
an
array,
replace
the
subject
definition
that
matches
id
with
a
subject
reference
.
If
parent
is
a
JSON
object
,
replace
the
subject
definition
for
property
that
matches
id
with
a
subject
reference
.
Remove
dependents
for
id
in
map
of
embeds
by
scanning
the
map
for
entries
with
parent
that
have
an
@id
of
id
,
removing
that
definition
from
the
map,
and
then
removing
the
dependents
for
the
parent
id
recursively
by
repeating
this
step.
This
step
will
terminate
when
there
are
no
more
embed
entries
containing
the
removed
subject
definition
's
@id
in
their
parent
chain.
3.11.5
Embed
Values
This
algorithm
recursively
embeds
property
values
in
subject
definition
output
,
given
a
framing
context
,
input
subject
definition
element
,
active
property
,
and
output
.
For
each
item
in
active
property
of
element
:
If
item
is
a
JSON
object
with
the
key
@list
,
then
create
a
new
JSON
object
with
a
key
@list
and
a
value
of
an
empty
array
and
add
it
to
output
,
appending
if
output
is
an
array,
and
appending
to
active
property
otherwise.
Recursively
call
this
algorithm
passing
item
as
element
,
@list
as
active
property
,
and
the
new
array
as
output
.
Continue
to
the
next
item
.
If
item
is
a
subject
reference
:
If
map
of
embeds
does
not
contain
an
entry
for
the
@id
of
item
:
Initialize
embed
with
output
as
parent
and
active
property
as
property
and
add
to
map
of
embeds
.
Initialize
a
new
subject
definition
o
to
act
as
the
embedded
subject
definition
.
For
each
property
and
value
in
the
expanded
definition
for
item
in
subjects
:
Add
property
and
a
copy
of
value
to
o
if
property
is
a
keyword
.
Otherwise,
recursively
call
this
algorithm
passing
value
as
element
,
property
as
active
property
and
o
as
output
.
Set
item
to
o
.
If
output
is
an
array
,
append
a
copy
of
item
,
otherwise
append
a
copy
of
item
to
active
property
in
output
.
3.12
Flattening
Flattening
is
the
process
of
taking
a
JSON-LD
document,
expanding
it,
labeling
all
unlabeled
nodes
with
a
blank
node
identifier,
and
returning
an
array
of
the
nodes
defined
in
the
document.
It
is
still
being
discussed
if
the
flatten()
method
should
be
added
or
not.
See
ISSUE-109
.
For
example,
assume
the
following
JSON-LD
input
document:
{
  &quot;@context&quot;: {
    &quot;name&quot;: &quot;http://xmlns.com/foaf/0.1/name&quot;,
    &quot;knows&quot;: &quot;foaf:knows&quot;
  },
  &quot;@id&quot;: &quot;http://example.com/markus&quot;,
  &quot;name&quot;: &quot;Markus Lanthaler&quot;,
  &quot;knows&quot;: {
    &quot;name&quot;: &quot;Manu Sporny&quot;
  }
}
Running
the
JSON-LD
Flattening
algorithm
for
the
merged
graph
(
@merged
)
against
the
JSON-LD
input
document
provided
above
would
result
in
the
following
output:
[
  {
    &quot;@id&quot;: &quot;http://example.com/markus&quot;,
    &quot;foaf:knows&quot;: [ { &quot;@id&quot;: &quot;_:t0&quot; }
    ],
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [ { &quot;@value&quot;: &quot;Markus Lanthaler&quot; } ]
  },
  {
    &quot;@id&quot;: &quot;_:t0&quot;,
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [ { &quot;@value&quot;: &quot;Manu Sporny&quot; } ]
  }
]
3.12.1
Flattening
Algorithm
The
algorithm
takes
two
input
variables,
an
element
to
flatten
and
the
graph
for
which
the
node
definitions
should
be
returned.
If
graph
is
not
set,
it
will
default
to
@merged
which
represents
the
result
of
merging
all
graphs
including
the
default
graph
(
@default
).
Expand
element
according
the
Expansion
Algorithm
.
Generate
a
subjectMap
according
the
Subject
Map
Generation
Algorithm
.
Initialize
an
empty
array
result
.
If
subjectMap
has
no
property
graph
,
return
result
,
otherwise
set
definitions
to
its
value.
Foreach
property
and
value
of
of
definitions
:
Add
value
to
result
.
Return
result
.
</del>
<div id="rdf-conversion" class="section">
<h3>
<span class="secno">
<del class="diff-old">3.13
</del>
<ins class="diff-chg">4.9
</ins>
</span>
RDF
Conversion
</h3>
<p>
A
JSON-LD
document
<em class="rfc2119" title="may">
may
</em>
be
converted
between
other
RDF-compatible
document
formats
using
the
algorithms
specified
in
this
section.
</p>
<p>
The
JSON-LD
Processing
Model
describes
processing
rules
for
extracting
RDF
from
a
JSON-LD
document,
and
for
transforming
an
array
of
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
retrieved
by
processing
another
serialization
format
into
JSON-LD.
Note
that
many
uses
of
JSON-LD
may
not
require
generation
of
RDF.
</p>
<p>
The
processing
algorithms
described
in
this
section
are
provided
in
order
to
demonstrate
how
one
might
implement
a
JSON-LD
to
RDF
processor.
Conformant
implementations
are
only
required
to
produce
the
same
type
and
number
of
quads
during
the
output
process
and
are
not
required
to
implement
the
algorithm
exactly
as
described.
</p>
<div class="informative section" id="overview">
<h4>
<span class="secno">
<del class="diff-old">3.13.1
</del>
<ins class="diff-chg">4.9.1
</ins>
</span>
Overview
</h4>
<p>
<em>
This
section
is
non-normative.
</em>
</p>
<p>
JSON-LD
is
intended
to
have
an
easy
to
parse
grammar
that
closely
models
existing
practice
in
using
JSON
for
describing
object
representations.
This
allows
the
use
of
existing
libraries
for
parsing
JSON.
</p>
<p>
As
with
other
grammars
used
for
describing
<a class="tref internalDFN" title="linked_data" href="#dfn-linked_data">
Linked
Data
</a>,
a
key
concept
is
that
of
a
<del class="diff-old">resource
.
Resources
</del>
<a class="tref internalDFN" title="node" href="#dfn-node">
<ins class="diff-chg">node
</ins></a><ins class="diff-chg">
in
a
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a>.<ins class="diff-chg">
Nodes
</ins>
may
be
of
three
basic
<del class="diff-old">types:
</del>
<ins class="diff-chg">types.
The
first
is
the
</ins>
<a class="datatype idlType" title="IRI" href="#idl-def-IRI">
<code>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</code>
</a>,
<del class="diff-old">representing
IRIs
</del>
<ins class="diff-chg">which
is
used
to
refer
to
</ins><a class="tref internalDFN" title="node" href="#dfn-node"><ins class="diff-chg">
node
</ins>
</a>
<del class="diff-old">for
describing
externally
named
entities,
BlankNode
</del>
<ins class="diff-chg">s
in
other
</ins><a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph"><ins class="diff-chg">
linked
data
graph
</ins></a><ins class="diff-chg">
s.
The
second
is
the
</ins><a class="tref internalDFN" title="blank_node" href="#dfn-blank_node"><ins class="diff-chg">
blank
node
</ins>
</a>,
<del class="diff-old">resources
</del>
<ins class="diff-chg">which
are
nodes
</ins>
for
which
an
external
name
does
not
exist,
or
is
not
<del class="diff-old">known,
and
</del>
<ins class="diff-chg">known.
The
third
is
a
</ins><a class="tref internalDFN" title="literal" href="#dfn-literal">
Literal
</a>,
which
<del class="diff-old">describe
terminal
entities
</del>
<ins class="diff-chg">express
values
</ins>
such
as
strings,
dates
and
other
<del class="diff-old">representations
</del>
<ins class="diff-chg">information
</ins>
having
a
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form,
</ins>
possibly
including
an
explicit
language
or
datatype.
</p>
<p>
Data
described
with
JSON-LD
may
be
considered
to
be
<del class="diff-old">the
representation
of
</del>
a
graph
made
up
of
<a class="tref internalDFN" title="subject" href="#dfn-subject">
subject
</a>
and
<a class="tref internalDFN" title="object" href="#dfn-object">
object
</a>
<del class="diff-old">resource
</del>
<a class="tref internalDFN" title="node" href="#dfn-node">
<ins class="diff-chg">nodes
</ins>
</a>
<del class="diff-old">s
</del>
related
via
a
<a class="tref internalDFN" title="property" href="#dfn-property">
property
</a>
<del class="diff-old">resource
</del>
<a class="tref internalDFN" title="node" href="#dfn-node">
<ins class="diff-chg">node
</ins>
</a>.
<del class="diff-old">However,
specific
</del>
<ins class="diff-chg">Specific
</ins>
implementations
may
<ins class="diff-new">also
</ins>
choose
to
operate
on
the
document
as
a
normal
JSON
description
of
objects
having
attributes.
<ins class="diff-new">Both
approaches
are
valid
ways
to
interact
with
JSON-LD
documents.
</ins>
</p>
</div>
<div class="informative section" id="parsing-examples">
<h4>
<span class="secno">
<del class="diff-old">3.13.2
</del>
<ins class="diff-chg">4.9.2
</ins>
</span>
<del class="diff-old">RDF
Conversion
Algorithm
Terms
</del>
<ins class="diff-chg">Parsing
Examples
</ins>
</h4>
<del class="diff-old">graph
name
</del>
<p>
<del class="diff-old">A
</del>
<em>
<ins class="diff-chg">This
section
is
non-normative.
</ins></em>
</p>
<p>
<ins class="diff-chg">The
following
examples
show
simple
transformations
of
JSON-LD
documents
to
Turtle
[
</ins><cite>
<del class="diff-old">IRI
</del>
<a class="bibref" rel="biblioentry" href="#bib-TURTLE-TR">
<ins class="diff-chg">TURTLE-TR
</ins></a>
</cite>
<ins class="diff-chg">].
</ins></p><p><ins class="diff-chg">
The
first
example
uses
a
simple
document
containing
a
simple
FOAF
profile:
</ins></p><div class="example"><div class="example-title"><span>Example 18</span></div><pre class="example">{<ins class="diff-chg">
  &quot;@context&quot;: {&quot;foaf&quot;: &quot;http://xmlns.com/foaf/0.1/&quot;},
  &quot;@id&quot;: &quot;http://greggkellogg.net/foaf#me&quot;,
  &quot;@type&quot;: &quot;foaf:Person&quot;,
  &quot;foaf:name&quot;: &quot;Gregg Kellogg&quot;,
  &quot;foaf:knows&quot;: {
    &quot;@type&quot;: &quot;foaf:Person&quot;,
    &quot;foaf:name&quot;: &quot;Manu Sporny&quot;
  }
}
</ins></pre>
<del class="diff-old">or
</del>
</div>
<p>
<ins class="diff-chg">This
translates
fairly
directly
to
a
similar
Turtle
document:
</ins></p><div class="example"><div class="example-title"><span>Example 19</span></div><pre class="example">@prefix foaf: &lt;http://xmlns.com/foaf/0.1/&gt;.<ins class="diff-chg">
&lt;http://greggkellogg.net/foaf#me&gt; a foaf:Person;
  foaf:name &quot;Gregg Kellogg&quot;;
foaf:knows
[
a
foaf:Person;
foaf:name
&quot;Manu
Sporny&quot;].
</ins></pre>
</div>
<p>
<ins class="diff-new">The
actual
parsing
steps
first
require
that
the
JSON-LD
document
be
expanded,
to
eliminate
the
</ins>
<code>
<del class="diff-old">BlankNode
</del>
<ins class="diff-chg">@context
</ins></code>:</p><div class="example"><div class="example-title"><span>Example 20</span></div><pre class="example">[{<ins class="diff-chg">
  &quot;@id&quot;: &quot;http://greggkellogg.net/foaf#me&quot;,
  &quot;@type&quot;: [&quot;http://xmlns.com/foaf/0.1/Person&quot;],
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{&quot;@value&quot;: &quot;Gregg Kellogg&quot;}],
  &quot;http://xmlns.com/foaf/0.1/knows&quot;: [{
    &quot;@type&quot;: [&quot;http://xmlns.com/foaf/0.1/Person&quot;],
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [{&quot;@value&quot;: &quot;Manu Sporny&quot;}]
  }]
}]
</ins></pre>
<del class="diff-old">used
</del>
</div>
<p>
<ins class="diff-chg">The
process
of
translating
this
</ins>
to
<del class="diff-old">identify
quads
belonging
</del>
<ins class="diff-chg">RDF
then
operates
over
each
</ins><a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition"><ins class="diff-chg">
subject
definition
</ins></a>
to
<ins class="diff-new">find
</ins>
a
<ins class="diff-new">subject,
each
</ins><a class="tref internalDFN" title="property" href="#dfn-property"><ins class="diff-new">
property
</ins></a><ins class="diff-new">
to
find
an
RDF
</ins>
<em>
<del class="diff-old">named
graph
.
</del>
<ins class="diff-chg">predicate
</ins></em>,<ins class="diff-chg">
and
each
value
of
that
property
to
find
an
</ins><a class="tref internalDFN" title="object" href="#dfn-object"><ins class="diff-chg">
object
</ins></a>.<ins class="diff-chg">
In
this
case,
each
property
has
just
a
single
object:
</ins><code><ins class="diff-chg">
foaf:name
</ins></code><ins class="diff-chg">
identifies
a
</ins><a class="tref internalDFN" title="literal" href="#dfn-literal"><ins class="diff-chg">
literal
</ins></a>,<ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
foaf:knows
</ins></code><ins class="diff-chg">
identifies
a
second
</ins><a class="tref internalDFN" title="subject_definition" href="#dfn-subject_definition"><ins class="diff-chg">
subject
definition
</ins></a><ins class="diff-chg">
similar
to
Turtle's
</ins><code><ins class="diff-chg">
blankNodePropertyList
</ins></code>.</p><p><ins class="diff-chg">
After
expansion,
JSON-LD
</ins><a class="tref internalDFN" title="number" href="#dfn-number"><ins class="diff-chg">
numbers
</ins></a>,<a class="tref internalDFN" title="true" href="#dfn-true"><ins class="diff-chg">
booleans
</ins></a>,<ins class="diff-chg">
typed-
and
language-tagged-
</ins><a class="tref internalDFN" title="literal" href="#dfn-literal"><ins class="diff-chg">
literals
</ins></a>,<ins class="diff-chg">
and
</ins><a class="tref internalDFN" title="iri" href="#dfn-iri"><ins class="diff-chg">
IRIs
</ins></a><ins class="diff-chg">
become
explicit,
and
can
be
directly
transformed
into
their
RDF
representations.
</ins></p><div class="example"><div class="example-title"><span>Example 21</span></div><pre class="example">[{<ins class="diff-chg">
  &quot;@id&quot;: &quot;http://greggkellogg.net/foaf#me&quot;,
  &quot;@type&quot;: [&quot;http://xmlns.com/foaf/0.1/Person&quot;],
  &quot;http://xmlns.com/foaf/0.1/name&quot;: [{&quot;@value&quot;: &quot;Gregg Kellogg&quot;}],
</ins>  <span class="diff">&quot;http://xmlns.com/foaf/0.1/currentProject&quot;: [{&quot;@id&quot;: &quot;http://json-ld.org/&quot;}],<ins class="diff-chg">
  &quot;http://xmlns.com/foaf/0.1/birthday&quot;: [{
    &quot;@value&quot;: &quot;1957-02-27&quot;,
    &quot;@type&quot;: &quot;http://www.w3.org/2001/XMLSchema#date&quot;
  }],</span>
  &quot;http://xmlns.com/foaf/0.1/knows&quot;: [{
    &quot;@type&quot;: [&quot;http://xmlns.com/foaf/0.1/Person&quot;],
    &quot;http://xmlns.com/foaf/0.1/name&quot;: [{&quot;@value&quot;: &quot;Manu Sporny&quot;}]
  }]
}]
</ins></pre>
</div>
<p>
<ins class="diff-chg">Translates
to:
</ins></p><div class="example"><div class="example-title"><span>Example 22</span></div><pre class="example">@prefix foaf: &lt;http://xmlns.com/foaf/0.1/&gt;.<ins class="diff-chg">
@prefix xsd: &lt;http://www.w3.org/2001/XMLSchema#&gt;.
&lt;http://greggkellogg.net/foaf#me&gt; a foaf:Person;
  foaf:name &quot;Gregg Kellogg&quot;;
</ins>  <span class="diff">foaf:currentProject &lt;http://json-ld.org/&gt;;<ins class="diff-chg">
  foaf:birthday &quot;1957-02-27&quot;^^xsd:date;</span>
foaf:knows
[
a
foaf:Person;
foaf:name
&quot;Manu
Sporny&quot;].
</ins></pre></div></div><div id="convert-to-rdf-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.13.3
</del>
<ins class="diff-chg">4.9.3
</ins>
</span>
Convert
to
RDF
Algorithm
</h4>
<p>
The
algorithm
below
is
designed
for
in-memory
implementations
with
random
access
to
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
elements.
</p>
<p>
A
conforming
JSON-LD
processor
implementing
RDF
conversion
<em class="rfc2119" title="must">
must
</em>
implement
a
processing
algorithm
that
results
in
the
same
set
of
RDF
<a class="tref internalDFN" title="quad" href="#dfn-quad">
Quads
</a>
that
the
following
algorithm
generates:
</p>
<p>
The
algorithm
takes
five
input
variables:
a
<em>
element
</em>
to
be
converted,
an
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
<a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">
graph
name
</a>.
To
begin,
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
<a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">
graph
name
</a>
are
set
to
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
and
<em>
element
</em>
is
set
to
the
result
of
performing
the
<a href="#expansion-algorithm">
Expansion
Algorithm
</a>
on
the
<a class="tref internalDFN" title="json-ld_input" href="#dfn-json-ld_input">
JSON-LD
input
</a>.
This
removes
any
existing
context
to
allow
the
given
context
to
be
cleanly
applied.
</p>
<ol class="algorithm">
<li id="processing-step-associative">
If
<em>
element
</em>
is
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>,
perform
the
following
steps:
<ol class="algorithm">
<li>
Set
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>.
</li>
<li>
If
<em>
element
</em>
has
a
<code>
@value
</code>
property:
<ol class="algorithm">
<li>
If
the
value
of
<code>
@value
</code>
is
a
<a class="tref internalDFN" title="number" href="#dfn-number">
number
</a>,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
using
a
string
representation
of
the
value
as
defined
in
the
section
<a href="#data-round-tripping">
Data
Round
Tripping
</a>.
Set
datatype
to
the
value
of
the
<code>
@type
</code>
property
if
it
exists,
otherwise
either
<code>
xsd:integer
</code>
or
<code>
xsd:double
</code>,
depending
on
if
the
value
contains
a
fractional
and/or
an
exponential
component.
</li>
<li>
Otherwise,
if
the
value
of
<code>
@value
</code>
is
<strong>
true
</strong>
or
<strong>
false
</strong>,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>
created
from
the
string
representation
of
the
value.
Set
datatype
to
the
value
of
the
<code>
@type
</code>
property
if
it
exists,
otherwise
<code>
xsd:boolean
</code>.
</li>
<li>
Otherwise,
if
<em>
element
</em>
contains
a
<code>
@type
</code>
property,
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
typed
literal
</a>.
</li>
<li>
Otherwise,
<ins class="diff-new">if
</ins><em><ins class="diff-new">
element
</ins></em><ins class="diff-new">
contains
a
</ins><code><ins class="diff-new">
@language
</ins></code><ins class="diff-new">
property,
</ins>
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
a
<del class="diff-old">plain
</del>
<a class="tref internalDFN" title="language-tagged_literal" href="#dfn-language-tagged_literal">
<ins class="diff-chg">language-tagged
</ins>
literal
</a>.
<del class="diff-old">If
element
contains
</del>
</li>
<li>
<ins class="diff-chg">Otherwise,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-chg">
active
object
</ins></a><ins class="diff-chg">
to
</ins>
a
<a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">
<ins class="diff-new">typed
literal
</ins></a><ins class="diff-new">
using
</ins>
<code>
<del class="diff-old">@language
</del>
<ins class="diff-chg">xsd:string
</ins>
</code>
<del class="diff-old">property,
use
its
value
to
set
the
language
of
</del>
<ins class="diff-chg">as
</ins>
the
<del class="diff-old">plain
literal.
</del>
<ins class="diff-chg">datatype.
</ins>
</li>
</ol>
</li>
<li>
If
<em>
element
</em>
has
a
<code>
@list
</code>
property
the
value
<em class="rfc2119" title="must">
must
</em>
be
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
Process
its
value
as
a
list
as
described
in
<a href="#list-conversion">
List
Conversion
</a>
using
the
return
value
as
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
</li>
<li>
If
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
is
not
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>:
<ol class="algorithm">
<li>
If
neither
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
nor
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
are
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
generate
a
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
representing
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>,
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>,
and
<a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">
graph
name
</a>.
</li>
<li>
Return
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
</li>
</ol>
</li>
<li id="processing-step-subject">
If
<em>
element
</em>
has
a
<code>
@id
</code>
property,
the
value
<em class="rfc2119" title="must">
must
</em>
be
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
set
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
to
the
previously
expanded
value
(either
a
<del class="diff-old">BlankNode
</del>
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
<ins class="diff-chg">blank
node
</ins>
</a>
or
an
<a class="datatype idlType" title="IRI" href="#idl-def-IRI">
<code>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</code>
</a>
).
</li>
<li>
Otherwise,
if
<em>
element
</em>
does
not
have
a
<code>
@id
</code>
property,
set
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
to
newly
generated
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
blank
node
</a>.
</li>
<li>
Process
each
<em>
property
</em>
and
<em>
value
</em>
in
<em>
element
</em>,
ordered
by
<em>
property
</em>,
as
follows:
<ol class="algorithm">
<li>
If
<em>
property
</em>
is
<code>
@type
</code>,
set
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
<code>
rdf:type
</code>.
</li>
<li>
Otherwise,
if
<em>
property
</em>
is
<code>
@graph
</code>,
process
<em>
value
</em>
algorithm
recursively,
using
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
as
<a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">
graph
name
</a>
and
null
values
for
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
and
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
then
proceed
to
next
property.
</li>
<li>
Otherwise,
if
<em>
property
</em>
is
a
<a class="tref internalDFN" title="keyword" href="#dfn-keyword">
keyword
</a>,
skip
this
step.
</li>
<li>
Otherwise,
set
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
to
the
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
value
of
<em>
property
</em>.
</li>
<li>
Process
<em>
value
</em>
recursively
using
this
algorithm,
passing
copies
of
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
<a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">
graph
name
</a>.
</li>
</ol>
</li>
<li>
Set
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>.
</li>
</ol>
</li>
<li>
Otherwise,
if
<em>
element
</em>
is
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>,
process
each
value
in
the
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
as
follows,
process
<em>
element
</em>
recursively
using
this
algorithm,
using
copies
of
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>,
and
<a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">
graph
name
</a>.
</li>
<li>
Otherwise,
if
<em>
element
</em>
is
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>,
then
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
must
be
<code>
rdf:type
</code>
so
set
the
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
to
an
<a class="datatype idlType" title="IRI" href="#idl-def-IRI">
<code>
<abbr title="Internationalized Resource Identifier">
IRI
</abbr>
</code>
</a>.
</li>
<li>
If
any
of
these
steps
created
an
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
and
neither
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>
nor
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
are
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
generate
a
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
using
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>,
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
and
<a class="tref internalDFN" title="graph_name" href="#dfn-graph_name">
graph
name
</a>.
</li>
<li>
Return
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>.
</li>
</ol>
</div>
<div id="list-conversion" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.13.4
</del>
<ins class="diff-chg">4.9.4
</ins>
</span>
List
Conversion
</h4>
<p>
List
Conversion
is
the
process
of
taking
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
of
values
and
adding
them
to
a
newly
created
<cite>
<a href="http://www.w3.org/TR/rdf-schema/#ch_collectionvocab">
RDF
Collection
</a>
</cite>
(see
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDF-SCHEMA">
RDF-SCHEMA
</a>
</cite>
])
by
linking
each
element
of
the
list
using
<code>
rdf:first
</code>
and
<code>
rdf:next
</code>,
terminating
the
list
with
<code>
rdf:nil
</code>
using
the
following
sequence:
</p>
<p>
The
algorithm
is
invoked
with
an
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>
<em>
array
</em>,
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
returns
a
value
to
be
used
as
an
<a class="tref internalDFN" title="active_object" href="#dfn-active_object">
active
object
</a>
in
the
calling
location.
</p>
<div class="note">
<div class="note-title">
<span>
<ins class="diff-new">Note
</ins></span></div><div class="">
This
algorithm
does
not
support
lists
containing
lists.
</div>
</div>
<ol class="algorithm">
<li>
If
<em>
array
</em>
is
empty
return
<code>
rdf:nil
</code>.
</li>
<li>
Otherwise,
generate
a
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
using
using
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>
and
a
newly
generated
<del class="diff-old">BlankNode
</del>
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
<ins class="diff-chg">blank
node
</ins>
</a>
identified
as
<em>
first
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
blank
node
</a>
</em>.
</li>
<li>
For
each
element
in
<em>
array
</em>
other
than
the
last
element:
<ol class="algorithm">
<li>
Create
a
processor
state
using
<em>
first
blank
node
</em>
as
the
<a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">
active
subject
</a>,
and
<code>
rdf:first
</code>
as
the
<a class="tref internalDFN" title="active_property" href="#dfn-active_property">
active
property
</a>.
<ol class="algorithm">
<li>
Process
the
value
starting
at
<a href="#processing-step-associative">
Step
1
</a>.
</li>
<li>
Proceed
using
the
previous
<a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">
processor
state
</a>.
</li>
</ol>
</li>
<li>
Unless
this
is
the
last
element
in
<em>
array
</em>,
generate
a
new
<del class="diff-old">BlankNode
</del>
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
<ins class="diff-chg">blank
node
</ins>
</a>
identified
as
<em>
rest
blank
node
</em>,
otherwise
use
<code>
rdf:nil
</code>.
</li>
<li>
Generate
a
new
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
using
<em>
first
blank
node
</em>,
<code>
rdf:rest
</code>
and
<em>
rest
blank
node
</em>.
</li>
<li>
Set
<em>
first
blank
node
</em>
to
<em>
rest
blank
node
</em>.
</li>
<li>
Return
<em>
first
blank
node
</em>.
</li>
</ol>
</li>
</ol>
</div>
<div id="convert-from-rdf-algorithm" class="section">
<h4>
<span class="secno">
<del class="diff-old">3.13.5
</del>
<ins class="diff-chg">4.9.5
</ins>
</span>
Convert
from
RDF
Algorithm
</h4>
<p>
In
some
cases,
data
exists
natively
in
Triples
or
Quads
form;
for
example,
if
the
data
was
originally
represented
in
an
RDF
graph
or
triple/quad
store.
This
algorithm
is
designed
to
simply
translate
an
array
of
<a class="datatype idlType" title="quad" href="#idl-def-quad">
<code>
Quads
</code>
</a>
into
a
JSON-LD
document.
</p>
<p>
<ins class="diff-new">When
expanding
</ins><a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal"><ins class="diff-new">
typed
literal
</ins></a><ins class="diff-new">
values
having
a
datatype
of
</ins><code><ins class="diff-new">
xsd:string
</ins></code>,<ins class="diff-new">
the
</ins><code><ins class="diff-new">
@type
</ins></code><em class="rfc2119" title="must not"><ins class="diff-new">
must
not
</ins></em><ins class="diff-new">
be
set
to
</ins><code><ins class="diff-new">
xsd:string
</ins></code><ins class="diff-new">
and
the
resulting
value
</ins><em class="rfc2119" title="must"><ins class="diff-new">
must
</ins></em><ins class="diff-new">
have
only
a
</ins><code><ins class="diff-new">
@value
</ins></code><ins class="diff-new">
property.
</ins></p><p>
The
conversion
algorithm
takes
a
single
parameter
<em>
input
</em>
in
the
form
of
an
array
of
<a href="#idl-def-Quad" class="idlType">
<code>
Quad
</code>
</a>
representations.
</p>
<ol class="algorithm">
<li id="new_graph">
Construct
<em>
defaultGraph
</em>
as
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
containing
<em>
subjects
</em>
and
<em>
listMap
<del class="diff-old">,each
</del>
</em>,
<ins class="diff-chg">each
</ins>
an
empty
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>.
</li>
<li>
Construct
<em>
graphs
</em>
as
a
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
containing
<em>
defaultGraph
</em>
identified
by
an
empty
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>.
</li>
<li>
For
each
quad
in
<em>
input
</em>:
<ol class="algorithm">
<li>
Set
<em>
graph
</em>
to
the
entry
in
<em>
graphs
</em>
identified
by
<em>
name
</em>,
initializing
it
to
a
new
entry
using
the
mechanism
described
in
<a href="#new_graph">
Step
1
</a>.
</li>
<li>
If
<em>
property
</em>
is
<code>
rdf:first
</code>,
use
the
entry
in
<em>
graph.listMap
</em>
indexed
by
<em>
subject
</em>,
initializing
it
to
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
if
nesessary.
Represent
<em>
object
</em>
in
expanded
form,
as
described
in
<a href="#value-expansion">
Value
Expansion
</a>.
Add
the
resulting
<em>
object
representation
</em>
to
the
entry
indexed
by
<em>
first
</em>,
and
skip
to
the
next
quad.
</li>
<li>
If
<em>
property
</em>
is
<code>
rdf:rest
</code>:
<ol class="algorithm">
<li>
If
<em>
object
</em>
is
a
<del class="diff-old">BlankNode
</del>
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
<ins class="diff-chg">blank
node
</ins>
</a>,
use
the
entry
in
<em>
graph.listMap
</em>
indexed
by
<em>
subject
</em>,
initializing
it
to
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
if
necessary.
Add
the
<em>
nominalValue
</em>
of
<em>
object
</em>
to
the
entry
indexed
by
<em>
rest
</em>.
</li>
<li>
Skip
to
the
next
quad.
</li>
</ol>
</li>
<li>
If
<em>
name
</em>
is
not
<a class="tref internalDFN" title="null" href="#dfn-null">
null
</a>,
and
<em>
defaultGraph.subjects
</em>
does
not
contain
an
entry
for
<em>
name
</em>,
create
a
new
entry
for
<em>
name
</em>
from
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
with
key/value
pair
of
<code>
@id
</code>
and
a
string
representation
of
<em>
name
</em>.
</li>
<li>
Set
<em>
value
</em>
as
the
entry
from
<em>
graph.subjects
</em>
for
<em>
subject
</em>,
initializing
it
to
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
with
key/value
pair
of
<code>
@id
</code>
and
a
string
representation
of
<em>
subject
</em>
if
necessary.
</li>
<li>
If
<em>
property
</em>
is
<code>
rdf:type
</code>
and
the
<em>
notType
</em>
option
is
present
and
not
<a class="tref internalDFN" title="true" href="#dfn-true">
true
</a>:
<ol class="algorithm">
<li>
Append
the
string
representation
of
<em>
object
</em>
to
the
array
value
for
the
key
<code>
@type
</code>,
creating
an
entry
in
<em>
value
</em>
if
necessary.
</li>
</ol>
</li>
<li>
Otherwise,
if
<em>
object
</em>
is
<code>
rdf:nil
</code>:
<ol class="algorithm">
<li>
Let
<em>
key
</em>
be
the
string
representation
of
<em>
property
</em>.
</li>
<li>
Append
an
empty
<code>
@list
</code>
representation
to
the
array
value
for
<em>
key
</em>,
creating
an
entry
in
<em>
value
</em>
if
necessary.
</li>
</ol>
</li>
<li>
Otherwise,
<ol class="algorithm">
<li>
Let
<em>
key
</em>
be
the
string
representation
of
<em>
property
</em>
and
let
<em>
object
representation
</em>
be
<em>
object
</em>
represented
in
expanded
form
as
described
in
<a href="#value-expansion">
Value
Expansion
</a>.
</li>
<li>
If
<em>
object
</em>
is
a
<del class="diff-old">BlankNode
</del>
<a class="tref internalDFN" title="blank_node" href="#dfn-blank_node">
<ins class="diff-chg">blank
node
</ins>
</a>,
use
the
entry
in
<em>
graph.listMap
</em>
indexed
by
<em>
object
</em>,
initializing
it
to
a
new
<a class="tref internalDFN" title="json_object" href="#dfn-json_object">
JSON
object
</a>
if
nesessary.
Add
an
entry
for
<em>
head
</em>
with
<em>
object
representation
</em>.
</li>
<li>
Append
<em>
object
representation
</em>
to
the
array
value
for
<em>
key
</em>,
creating
an
entry
in
<em>
value
</em>
if
necessary.
</li>
</ol>
</li>
</ol>
</li>
<li>
For
each
<em>
name
</em>
and
<em>
graph
</em>
in
<em>
graphs
</em>:
<ol class="algorithm">
<li>
For
each
<em>
subject
</em>
and
<em>
entry
</em>
in
<em>
graph
</em>
where
<em>
entry
</em>
has
both
<em>
head
</em>
and
<em>
first
</em>
keys:
<ol class="algorithm">
<li>
Set
<em>
value
</em>
to
the
value
of
<em>
head
</em>
in
<em>
entry
</em>.
</li>
<li>
Remove
the
entry
for
<code>
@id
</code>
in
<em>
value
</em>.
</li>
<li>
Add
an
entry
to
<em>
value
</em>
for
<code>
@list
</code>
initialized
to
a
new
array
containing
the
value
of
<em>
first
</em>
from
<em>
entry
</em>.
</li>
<li>
While
<em>
entry
</em>
has
a
key
for
<em>
rest
</em>:
<ol class="algorithm">
<li>
Set
<em>
entry
</em>
to
the
value
of
<em>
graph.listMap
</em>
for
<em>
entry.rest
</em>.
</li>
<li>
Add
the
value
for
<em>
entry.first
</em>
to
the
list
array.
</li>
</ol>
</li>
</ol>
</li>
</ol>
</li>
<li>
Create
<em>
array
</em>
as
an
empty
<a class="tref internalDFN" title="array" href="#dfn-array">
array
</a>.
</li>
<li>
For
each
<em>
subject
</em>
and
<em>
entry
</em>
in
<em>
defaultGraph.subjects
</em>
ordered
by
<em>
subject
</em>:
<ol class="algorithm">
<li>
Add
<em>
entry
</em>
to
<em>
array
</em>.
</li>
<li>
If
<em>
graphs
</em>
has
an
entry
for
<em>
subject
</em>,
add
a
property
<code>
@graph
</code>
in
<em>
entry
</em>
containing
the
ordered
entries
from
<em>
graphs[subject].subjects
</em>.
</li>
</ol>
</li>
<li>
Return
<em>
array
</em>
as
the
result.
</li>
</ol>
</div>
</div>
</div>
<div id="data-round-tripping" class="section">
<h2>
<span class="secno">
<del class="diff-old">4.
</del>
<ins class="diff-chg">5.
</ins>
</span>
Data
Round
Tripping
</h2>
<p>
When
coercing
numbers
to
<strong>
xsd:integer
</strong>
or
<strong>
xsd:double
</strong>
as
it,
e.g.,
happens
during
<a href="#rdf-conversion">
RDF
Conversion
</a>,
implementers
<em class="rfc2119" title="must">
must
</em>
ensure
that
the
result
is
a
canonical
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form
</ins>
in
the
form
of
a
<a class="tref internalDFN" title="string" href="#dfn-string">
string
</a>.
A
<dfn title="canonical_lexical_form" id="dfn-canonical_lexical_form">
canonical
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form
</ins>
</dfn>
is
a
set
of
literals
from
among
the
valid
set
of
literals
for
a
datatype
such
that
there
is
a
one-to-one
mapping
between
the
canonical
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form
</ins>
and
a
value
in
the
value
space
as
defined
in
[
<cite>
<del class="diff-old">XMLSCHEMA-2
</del>
<a class="bibref" rel="biblioentry" href="#bib-XMLSCHEMA11-2">
<ins class="diff-chg">XMLSCHEMA11-2
</ins>
</a>
</cite>
<del class="diff-old">].
</del>
<ins class="diff-chg">]].
</ins>
In
other
words,
every
value
<em class="rfc2119" title="must">
must
</em>
be
converted
to
a
deterministic
string
representation.
</p>
<p>
The
canonical
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form
</ins>
of
an
<em>
integer
</em>,
i.e.,
a
number
without
fractions
or
a
number
coerced
to
<strong>
xsd:integer
</strong>,
is
a
finite-length
sequence
of
decimal
digits
(
<code>
0-9
</code>
)
with
an
optional
leading
minus
sign;
leading
zeroes
are
prohibited.
To
convert
the
number
in
JavaScript,
implementers
can
use
the
following
snippet
of
code:
</p>
<div class="example">
<div class="example-title">
<span>
<ins class="diff-new">Example
23
</ins></span></div>
<pre class="example">
(value).toFixed(0).toString()
</pre>
</div>
<p>
The
canonical
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form
</ins>
of
a
<em>
double
</em>,
i.e.,
a
number
with
fractions
or
a
number
coerced
to
<strong>
xsd:double
</strong>,
consists
of
a
mantissa
followed
by
the
character
&quot;E&quot;,
followed
by
an
exponent.
The
mantissa
<em class="rfc2119" title="must">
must
</em>
be
a
decimal
number.
The
exponent
<em class="rfc2119" title="must">
must
</em>
be
an
integer.
Leading
zeroes
and
a
preceding
plus
sign
(
<code>
+
</code>
)
are
prohibited
in
the
exponent.
If
the
exponent
is
zero,
it
must
be
indicated
by
<code>
E0
</code>.
For
the
mantissa,
the
preceding
optional
plus
sign
is
prohibited
and
the
decimal
point
is
required.
Leading
and
trailing
zeroes
are
prohibited
subject
to
the
following:
number
representations
must
be
normalized
such
that
there
is
a
single
digit
which
is
non-zero
to
the
left
of
the
decimal
point
and
at
least
a
single
digit
to
the
right
of
the
decimal
point
unless
the
value
being
represented
is
zero.
The
canonical
representation
for
zero
is
<code>
0.0E0
</code>.
To
convert
the
number
in
JavaScript,
implementers
can
use
the
following
snippet
of
code:
</p>
<div class="example">
<div class="example-title">
<span>
<ins class="diff-new">Example
24
</ins></span></div>
<pre class="example">
(value).toExponential().replace(/e\+?/,'E')
</pre>
</div>
<p>
<strong>
xsd:double
</strong>
's
value
space
is
defined
by
the
IEEE
double-precision
64-bit
floating
point
type
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-IEEE-754-1985">
IEEE-754-1985
</a>
</cite>
].
</p>
<div class="note">
<div class="note-title">
<span>
<ins class="diff-chg">Note
</ins></span></div><p class="">
When
data
such
as
decimals
need
to
be
normalized,
JSON-LD
authors
should
not
use
values
that
are
going
to
undergo
automatic
conversion.
This
is
due
to
the
lossy
nature
of
<strong>
xsd:double
</strong>
values.
Authors
should
instead
use
the
expanded
object
form
to
set
the
canonical
lexical
<del class="diff-old">representation
</del>
<ins class="diff-chg">form
</ins>
directly.
</p>
</div>
<div class="note">
<div class="note-title">
<span>
<ins class="diff-chg">Note
</ins></span></div><p class="">
When
JSON-native
datatypes,
like
<a class="tref internalDFN" title="number" href="#dfn-number">
number
</a>
s,
are
type
coerced,
lossless
data
round-tripping
can
not
be
guaranted.
Consider
the
following
code
example:
</p>
<del class="diff-old">var myObj1 = {
</del>
</div>
<div class="example"><div class="example-title"><span>Example 25</span></div><pre class="example">var myObj1 = {
               &quot;@context&quot;: {
                 &quot;number&quot;: {
                   &quot;@id&quot;: &quot;http://example.com/vocab#number&quot;,
                   <span class="diff">&quot;@type&quot;: &quot;xsd:nonNegativeInteger&quot;</span>
                 }
               },
               &quot;number&quot; : <span class="diff">42</span>
             };
// Convert the JSON-LD document to RDF; this converts 42 to a string
var jsonldText = jsonld.toRDF(myObj1, myRdfTripleCollector);
// Convert the RDF triples back to a JavaScript object
var
myObj2
=
jsonld.fromRDF(myRdfTripleCollector.getTriples());
</pre>
</div>
<p>
At
this
point,
<code>
myObj1
</code>
and
<code>
myObj2
</code>
will
have
different
values
for
the
&quot;number&quot;
property.
<code>
myObj1
</code>
will
have
the
number
<code>
42
</code>,
while
<code>
myObj2
</code>
have
an
object
consisting
of
<code>
@value
</code>
set
to
the
string
<code>
&quot;42&quot;
</code>
and
<code>
@type
</code>
set
to
the
expanded
value
of
<em>
xsd:nonNegativeInteger
</em>.
</p>
<div class="note">
<div class="note-title">
<span>
<ins class="diff-chg">Note
</ins></span></div><p class="">
Some
JSON
serializers,
such
as
PHP's
native
implementation
in
some
versions,
backslash-escape
the
forward
slash
character.
For
example,
the
value
<code>
http://example.com/
</code>
would
be
serialized
as
<code>
http:\/\/example.com\/
</code>.
This
is
problematic
as
other
JSON
parsers
might
not
understand
those
escaping
characters.
There
is
no
need
to
backslash-escape
forward
slashes
in
JSON-LD.
To
aid
interoperability
between
JSON-LD
processors,
a
JSON-LD
serializer
<em class="rfc2119" title="must not">
must
not
</em>
backslash-escape
forward
slashes.
</p>
</div>
</div>
<div class="appendix section" id="appendix-a">
<h2>
<span class="secno">
A.
</span>
<del class="diff-old">IANA
Considerations
</del>
<ins class="diff-chg">Initial
Context
</ins>
</h2>
<div class="issue">
<div class="issue-title">
<del class="diff-old">This
section
is
non-normative.
</del>
<span>
<ins class="diff-chg">Issue
8
</ins></span>
<del class="diff-old">This
section
is
included
merely
for
standards
community
review
and
will
be
submitted
to
the
Internet
Engineering
Steering
Group
if
this
specification
becomes
a
W3C
Recommendation.
application/ld-frame+json
Type
name:
application
Subtype
name:
ld-frame+json
Required
parameters:
None
Optional
parameters:
None
Encoding
considerations:
The
same
as
the
application/json
MIME
media
type.
Security
considerations:
Since
a
JSON-LD
frame
is
intended
to
specify
a
deterministic
layout
for
a
JSON-LD
graph,
the
serialization
should
not
be
passed
through
a
code
execution
mechanism
such
as
JavaScript's
eval()
function.
</del>
</div>
<p class="">
It
is
<del class="diff-old">recommended
that
a
conforming
parser
does
not
attempt
to
directly
evaluate
the
JSON-LD
frame
and
instead
purely
parse
the
input
into
a
language-native
data
structure.
Interoperability
considerations:
Not
Applicable
Published
specification:
The
JSON-LD
</del>
<a href="https://github.com/json-ld/json-ld.org/issues/80">
<ins class="diff-chg">still
being
discussed
</ins>
</a>
<del class="diff-old">specification.
Applications
that
use
this
media
type:
Any
programming
environment
that
requires
</del>
<ins class="diff-chg">whether
JSON-LD
has
</ins>
the
<del class="diff-old">exchange
of
directed
graphs.
Implementations
</del>
<ins class="diff-chg">notion
</ins>
of
<del class="diff-old">JSON-LD
have
been
created
for
JavaScript,
Python,
Ruby,
PHP
and
C++.
Additional
information:
Magic
number(s):
Not
Applicable
File
extension(s):
.jsonldf
Macintosh
file
type
code(s):
TEXT
Person
&amp;
email
address
to
contact
for
further
information:
Manu
Sporny
&lt;msporny@digitalbazaar.com&gt;
Intended
usage:
Common
Restrictions
on
usage:
None
Author(s):
Manu
Sporny,
Gregg
Kellogg,
Markus
Lanthaler,
Dave
Longley
Change
controller:
W3C
Fragment
identifiers
have
no
meaning
with
application/frame-ld+json
resources.
B.
Initial
Context
The
</del>
<ins class="diff-chg">an
</ins>
initial
context
<del class="diff-old">is
defined
with
the
following
default
entries:
{
  &quot;@context&quot;: {
    &quot;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&quot;: { &quot;@type&quot;: &quot;@id&quot;}
  }
}
Processors
</del>
<ins class="diff-chg">or
not.
If
JSON-LD
has
an
initial
context,
it
</ins>
<em class="rfc2119" title="must">
must
</em>
<del class="diff-old">act
as
if
the
initial
context
is
defined
in
</del>
<ins class="diff-chg">be
specified
external
to
</ins>
the
<del class="diff-old">outer-most
level
when
processing
</del>
JSON-LD
<del class="diff-old">documents.
Should
we
define
other
default
prefixes?
</del>
<ins class="diff-chg">Syntax
specification
at
a
well-known
location.
</ins>
</p>
</div>
</div>
<div class="appendix section" id="acknowledgements">
<h2>
<span class="secno">
<del class="diff-old">C.
</del>
<ins class="diff-chg">B.
</ins>
</span>
Acknowledgements
</h2>
<p>
The
editors
would
like
to
thank
Mark
Birbeck,
who
provided
a
great
deal
of
the
initial
push
behind
the
JSON-LD
work
via
his
work
on
RDFj,
Dave
Lehn
and
Mike
Johnson
who
reviewed,
provided
feedback,
and
performed
several
implementations
of
the
specification,
and
Ian
Davis,
who
created
RDF/JSON.
Thanks
also
to
Nathan
Rixham,
Bradley
P.
Allen,
Kingsley
Idehen,
Glenn
McDonald,
Alexandre
Passant,
Danny
Ayers,
Ted
Thibodeau
Jr.,
Olivier
Grisel,
<del class="diff-old">Niklas
Lindström,
Markus
Lanthaler,
</del>
<ins class="diff-chg">Josh
Mandel,
Eric
Prud'hommeaux,
David
Wood,
Guus
Schreiber,
Pat
Hayes,
Sandro
Hawke,
</ins>
and
Richard
Cyganiak
for
their
input
on
the
specification.
</p>
</div>
<div id="references" class="appendix section">
<h2>
<span class="secno">
<del class="diff-old">D.
</del>
<ins class="diff-chg">C.
</ins>
</span>
References
</h2>
<div id="normative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">D.1
</del>
<ins class="diff-chg">C.1
</ins>
</span>
Normative
references
</h3>
<dl class="bibliography">
<dt id="bib-BCP47">
[BCP47]
</dt>
<dd>
A.
<del class="diff-old">Phillips,
</del>
<ins class="diff-chg">Phillips;
</ins>
M.
Davis.
<a href="http://tools.ietf.org/html/bcp47">
<cite>
Tags
for
Identifying
Languages
</cite>
</a>
September
2009.
IETF
Best
Current
Practice.
URL:
<del class="diff-old">http://tools.ietf.org/rfc/bcp/bcp47.txt
</del>
<a href="http://tools.ietf.org/html/bcp47">
<ins class="diff-chg">http://tools.ietf.org/html/bcp47
</ins>
</a>
</dd>
<dt id="bib-IEEE-754-1985">
[IEEE-754-1985]
</dt>
<dd>
IEEE.
<cite>
IEEE
Standard
for
Binary
Floating-Point
Arithmetic.
</cite>
See
<a href="http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html">
http://standards.ieee.org/reading/ieee/std_public/description/busarch/754-1985_desc.html
</a>
</dd>
<del class="diff-old">[IRI]
</del>
<dt id="bib-JSON-LD">
<ins class="diff-chg">[JSON-LD]
</ins>
</dt>
<del class="diff-old">M.
Duerst,
M.
Suignard.
</del>
<dd>
<cite>
<del class="diff-old">Internationalized
Resource
Identifiers
(IRI).
</del>
<a href="http://json-ld.org/spec/ED/json-ld-syntax/20120522/">
<ins class="diff-new">The
JSON-LD
Syntax
</ins>
</a>
<del class="diff-old">January
2005.
Internet
RFC
3987.
URL:
http://www.ietf.org/rfc/rfc3987.txt
</del>
<del class="diff-old">[JSON-LD]
</del>
</cite>
Manu
Sporny,
Gregg
Kellogg,
Markus
<del class="diff-old">Lanthaler.
</del>
<ins class="diff-chg">Lanthaler
Editors.
World
Wide
Web
Consortium
(work
in
progress).
22
May
2012.
Editor's
Draft.
This
edition
of
the
JSON-LD
Syntax
specification
is
http://json-ld.org/spec/ED/json-ld-syntax/20120522/.
</ins>
The
<a href="http://json-ld.org/spec/latest/json-ld-syntax/">
<ins class="diff-new">latest
edition
of
the
</ins>
JSON-LD
Syntax
</a>
<del class="diff-old">Latest.
W3C
Editor's
Draft.
URL:
</del>
<ins class="diff-chg">is
available
at
</ins>
http://json-ld.org/spec/latest/json-ld-syntax/
</dd>
<dt id="bib-JSON-POINTER">
[JSON-POINTER]
</dt>
<del class="diff-old">P.
Bryan,
Ed.
</del>
<dd>
<cite>
<a href="http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-02">
JSON
Pointer
</a>
</cite>
<del class="diff-old">Latest.
</del>
<ins class="diff-chg">P.
Bryan,
Ed.
</ins>
IETF
Draft.
URL:
<del class="diff-old">http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-01
</del>
<a href="http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-02">
<ins class="diff-chg">http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-02
</ins>
</a>
</dd>
<dt id="bib-RDF-CONCEPTS">
[RDF-CONCEPTS]
</dt>
<del class="diff-old">Graham
Klyne;
Jeremy
J.
Carroll.
</del>
<dd>
<cite>
<del class="diff-old">Resource
Description
Framework
(RDF):
</del>
<a href="http://www.w3.org/TR/2011/WD-rdf11-concepts-20110830/">
<ins class="diff-chg">RDF
1.1
</ins>
Concepts
and
Abstract
<del class="diff-old">Syntax.
</del>
<ins class="diff-chg">Syntax
</ins>
</a>
<del class="diff-old">10
February
2004.
W3C
Recommendation.
URL:
http://www.w3.org/TR/2004/REC-rdf-concepts-20040210
</del>
</cite>
<ins class="diff-chg">Richard
Cyganiak,
David
Wood,
Editors.
World
Wide
Web
Consortium
(work
in
progress).
30
May
2012.
Editor's
Draft.
This
edition
of
the
JSON-LD
Syntax
specification
is
http://www.w3.org/TR/2011/WD-rdf11-concepts-20110830/.
The
</ins><a href="http://www.w3.org/TR/rdf11-concepts/"><ins class="diff-chg">
latest
edition
of
the
JSON-LD
Syntax
</ins>
</a>
<ins class="diff-new">is
available
at
http://www.w3.org/TR/rdf11-concepts/
</ins>
</dd>
<dt id="bib-RDF-SCHEMA">
[RDF-SCHEMA]
</dt>
<dd>
Dan
Brickley;
Ramanathan
V.
Guha.
<a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210">
<cite>
RDF
Vocabulary
Description
Language
1.0:
RDF
Schema.
</cite>
</a>
10
February
2004.
W3C
Recommendation.
URL:
<a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210">
http://www.w3.org/TR/2004/REC-rdf-schema-20040210
</a>
</dd>
<dt id="bib-RFC3986">
[RFC3986]
</dt>
<dd>
T.
Berners-Lee;
R.
Fielding;
L.
Masinter.
<a href="http://www.ietf.org/rfc/rfc3986.txt">
<cite>
Uniform
Resource
Identifier
(URI):
Generic
Syntax.
</cite>
</a>
January
2005.
Internet
RFC
3986.
URL:
<a href="http://www.ietf.org/rfc/rfc3986.txt">
http://www.ietf.org/rfc/rfc3986.txt
</a>
</dd>
<dt id="bib-RFC3987">
[RFC3987]
</dt>
<dd>
M.
Dürst;
M.
Suignard.
<a href="http://www.ietf.org/rfc/rfc3987.txt">
<cite>
Internationalized
Resource
Identifiers
(IRIs).
</cite>
</a>
January
2005.
Internet
RFC
3987.
URL:
<a href="http://www.ietf.org/rfc/rfc3987.txt">
http://www.ietf.org/rfc/rfc3987.txt
</a>
</dd>
<dt id="bib-RFC4627">
[RFC4627]
</dt>
<dd>
D.
Crockford.
<a href="http://www.ietf.org/rfc/rfc4627.txt">
<cite>
The
application/json
Media
Type
for
JavaScript
Object
Notation
(JSON)
</cite>
</a>
July
2006.
Internet
RFC
4627.
URL:
<a href="http://www.ietf.org/rfc/rfc4627.txt">
http://www.ietf.org/rfc/rfc4627.txt
</a>
</dd>
<dt id="bib-WEBIDL">
[WEBIDL]
</dt>
<del class="diff-old">Cameron
McCormack.
</del>
<dd>
<cite>
<del class="diff-old">Web
IDL.
</del>
<a href="http://www.w3.org/TR/2012/CR-WebIDL-20120419/">
<ins class="diff-new">Web
IDL
</ins>
</a>
<del class="diff-old">27
September
2011.
W3C
Working
Draft.
(Work
in
progress.)
URL:
http://www.w3.org/TR/2011/WD-WebIDL-20110927/
</del>
</cite>
<ins class="diff-chg">Cameron
McCormack,
Editor.
World
Wide
Web
Consortium.
19
April
2012.
Candidate
Recommendataion.
This
edition
of
Web
IDL
is
http://www.w3.org/TR/2012/CR-WebIDL-20120419/.
The
</ins><a href="http://dev.w3.org/2006/webapi/WebIDL/"><ins class="diff-chg">
latest
edition
of
Web
IDL
</ins>
</a>
<ins class="diff-new">is
available
at
http://dev.w3.org/2006/webapi/WebIDL/
</ins>
</dd>
<del class="diff-old">[XMLSCHEMA-2]
</del>
<dt id="bib-XMLSCHEMA11-2">
<ins class="diff-chg">[XMLSCHEMA11-2]
</ins>
</dt>
<del class="diff-old">Paul
V.
Biron;
Ashok
Malhotra.
</del>
<dd>
<ins class="diff-chg">Henry
S.
Thompson;
et
al.
</ins><a href="http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/">
<cite>
<ins class="diff-new">W3C
</ins>
XML
Schema
<ins class="diff-new">Definition
Language
(XSD)
1.1
</ins>
Part
2:
<del class="diff-old">Datatypes
Second
Edition.
</del>
<ins class="diff-chg">Datatypes.
</ins>
</cite>
</a>
<del class="diff-old">28
October
2004.
</del>
<ins class="diff-chg">5
April
2012.
</ins>
W3C
<del class="diff-old">Recommendation.
</del>
<ins class="diff-chg">Recommendation
</ins>
URL:
<del class="diff-old">http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/
</del>
<a href="http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/">
<ins class="diff-chg">http://www.w3.org/TR/2012/REC-xmlschema11-2-20120405/
</ins>
</a>
</dd>
</dl>
</div>
<div id="informative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">D.2
</del>
<ins class="diff-chg">C.2
</ins>
</span>
Informative
references
</h3>
<dl class="bibliography">
<dt id="bib-ECMA-262">
[ECMA-262]
</dt>
<dd>
<a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">
<cite>
ECMAScript
Language
Specification.
</cite>
</a>
December
1999.
URL:
<a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">
http://www.ecma-international.org/publications/standards/Ecma-262.htm
</a>
</dd>
<del class="diff-old">[MICRODATA]
</del>
<dt id="bib-TURTLE-TR">
<ins class="diff-chg">[TURTLE-TR]
</ins>
</dt>
<del class="diff-old">Ian
Hickson;
et
al.
</del>
<dd>
<ins class="diff-chg">Eric
Prud'hommeaux,
Gavin
Carothers.
</ins>
<cite>
<del class="diff-old">Microdata
</del>
<a href="http://www.w3.org/TR/2011/WD-turtle-20110809/">
<ins class="diff-new">Turtle:
Terse
RDF
Triple
Language.
</ins>
</a>
<del class="diff-old">04
March
2010.
</del>
</cite>
<ins class="diff-chg">09
August
2011.
</ins>
W3C
Working
Draft.
URL:
<del class="diff-old">http://www.w3.org/TR/microdata/
[MICROFORMATS]
Microformats
.
URL:
http://microformats.org
</del>
<a href="http://www.w3.org/TR/2011/WD-turtle-20110809/">
<ins class="diff-chg">http://www.w3.org/TR/2011/WD-turtle-20110809/
</ins>
</a>
</dd>
<del class="diff-old">[RDFA-CORE]
</del>
<dt id="bib-UNICODE">
<ins class="diff-chg">[UNICODE]
</ins>
</dt>
<del class="diff-old">Shane
McCarron;
et
al.
</del>
<dd>
<ins class="diff-chg">The
Unicode
Consortium.
</ins><a href="http://www.unicode.org/unicode/standard/versions/enumeratedversions.html">
<cite>
<del class="diff-old">RDFa
Core
1.1:
Syntax
and
processing
rules
for
embedding
RDF
through
attributes.
</del>
<ins class="diff-chg">The
Unicode
Standard.
</ins>
</cite>
</a>
<del class="diff-old">8
May
2012.
W3C
Proposed
Recommendation.
</del>
<ins class="diff-chg">2003.
Defined
by:
The
Unicode
Standard,
Version
4.0
(Boston,
MA,
Addison-Wesley,
ISBN
0-321-18578-1),
as
updated
from
time
to
time
by
the
publication
of
new
versions
</ins>
URL:
<del class="diff-old">http://www.w3.org/TR/2012/PR-rdfa-core-20120508/
</del>
<a href="http://www.unicode.org/unicode/standard/versions/enumeratedversions.html">
<ins class="diff-chg">http://www.unicode.org/unicode/standard/versions/enumeratedversions.html
</ins>
</a>
</dd>
</dl>
</div>
</div>
</body>
</html>
